Go逆向_2

字数统计: 17k字   |   阅读时长≈ 88分

Go内存模型，调用机制和PLAN9汇编

Go逆向_2

环境

1
go version go1.16.4 windows/amd64

是去年7月份下的。但是Go语言底层基本没什么变化，所以就暂且用这个版本。

基本使用

Go配备了一个齐全的工具链。

打印PLAN 9汇编

1
go build -gcflags -S xxx.go

这将直接在控制台界面上打印PLAN9汇编。

生成.o，.exe.以及PLAN9汇编

1
go tool compile -S xxx.go

直接全都生成了。

反汇编

1
2
go build -o xxx.exe xxx.go
go tool objdump -s main.main xxx.exe

反汇编出main.main函数的PLAN9汇编。

注意仅对未strip的程序有效。

关于-gcflags和-ldflags传参

-gcflags

gcflags就是传入compile工具的参数。所以

1
go tool compile --help

可以浏览-gcflags所有可传入参数。

调试情况下，通常使用的参数是：

  1. -N：不优化
  2. -l：不内联
1
go build -gcflags

-ldflags

是链接参数，传入link工具的。

1
go tool link --help

可以知晓所有参数。

可以传入

-compressdwarf=false参数，使得不压缩DWARF调试信息。

Go PLAN9汇编

Go汇编和一般x86汇编极其相似。此块作为参考部分使用，以防一些因细微差异导致的误解。

本文参考官方开发文档 https://go.dev/doc/asm#symbols 解释的比其他人的博客都要详细很多。

虽然本文处于开发角度而言的，且Go底层API很多都是直接靠Go汇编写出来的，所以还是值得一学。

Plan 9是个很古老的汇编体系。Go语言使用Plan 9汇编就是为了增加抽象性，便于跨平台。

不过，Go的Plan 9和最原始的Plan 9还是有不少区别的。

想看原始版本的可以看看这篇文章。

https://9p.io/sys/doc/asm.html

里面的寄存器为了适应多平台，起名皆是高度抽象的。不是本文重点。

本博客主要谈谈基于AMD64架构的Go Plan 9汇编，其中寄存器起名和实际寄存器都区别不大了；但是还是

简要

首先需要了解Go汇编的是，Go汇编不是直接描述某一种机器的汇编语言（比如x86，AMD64，MIPS，PPC等平台相关汇编）。Go汇编其中的某一些细节将精确地对应其机器平台，但是还有一些则不是。这是因为编译器套件在现在的编译流程中并不需要汇编器流程。相反的，Go编译器运行在一种半抽象指令集上，且指令选择部分发生于代码生成后。

所以说当你发现一个像MOV的Go汇编，工具链实际生成的机器汇编可能是load或者clear（众RISC架构）。当然也有可能MOVGo汇编正好就对应这机器平台上的mov汇编（x86，AMD64平台概率大）。

总结：Go汇编是抽象（Plan9）与具体架构的混合。

例子

先用go build -gcflags -S hello.go正向汇编程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
go build -gcflags -S .\hello.go
# command-line-arguments
"".main STEXT size=144 args=0x0 locals=0x58 funcid=0x0
        0x0000 00000 (hello.go:5) TEXT    "".main(SB), ABIInternal, $88-0
        0x0000 00000 (hello.go:5) MOVQ    TLS, CX
        0x0009 00009 (hello.go:5) PCDATA  $0, $-2
        0x0009 00009 (hello.go:5) MOVQ    (CX)(TLS*2), CX
        0x0010 00016 (hello.go:5) PCDATA  $0, $-1
        0x0010 00016 (hello.go:5) CMPQ    SP, 16(CX)
        0x0014 00020 (hello.go:5) PCDATA  $0, $-2
        0x0014 00020 (hello.go:5) JLS     134
        0x0016 00022 (hello.go:5) PCDATA  $0, $-1
        0x0016 00022 (hello.go:5) SUBQ    $88, SP
        0x001a 00026 (hello.go:5) MOVQ    BP, 80(SP)
        0x001f 00031 (hello.go:5) LEAQ    80(SP), BP
        0x0024 00036 (hello.go:5) FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0024 00036 (hello.go:5) FUNCDATA        $1, gclocals·f207267fbf96a0178e8758c6e3e0ce28(SB)
        0x0024 00036 (hello.go:5) FUNCDATA        $2, "".main.stkobj(SB)
        0x0024 00036 (hello.go:6) XORPS   X0, X0
        0x0027 00039 (hello.go:6) MOVUPS  X0, ""..autotmp_11+64(SP)
        0x002c 00044 (hello.go:6) LEAQ    type.string(SB), AX
        0x0033 00051 (hello.go:6) MOVQ    AX, ""..autotmp_11+64(SP)
        0x0038 00056 (hello.go:6) LEAQ    ""..stmp_0(SB), AX
        0x003f 00063 (hello.go:6) MOVQ    AX, ""..autotmp_11+72(SP)
        0x0044 00068 (<unknown line number>)    NOP
        0x0044 00068 ($GOROOT\src\fmt\print.go:274)     MOVQ    os.Stdout(SB), AX
        0x004b 00075 ($GOROOT\src\fmt\print.go:274)     LEAQ    go.itab.*os.File,io.Writer(SB), CX
        0x0052 00082 ($GOROOT\src\fmt\print.go:274)     MOVQ    CX, (SP)
        0x0056 00086 ($GOROOT\src\fmt\print.go:274)     MOVQ    AX, 8(SP)
        0x005b 00091 ($GOROOT\src\fmt\print.go:274)     LEAQ    ""..autotmp_11+64(SP), AX
        0x0060 00096 ($GOROOT\src\fmt\print.go:274)     MOVQ    AX, 16(SP)
        0x0065 00101 ($GOROOT\src\fmt\print.go:274)     MOVQ    $1, 24(SP)
        0x006e 00110 ($GOROOT\src\fmt\print.go:274)     MOVQ    $1, 32(SP)
        0x0077 00119 ($GOROOT\src\fmt\print.go:274)     PCDATA  $1, $0
        0x0077 00119 ($GOROOT\src\fmt\print.go:274)     CALL    fmt.Fprintln(SB)
        0x007c 00124 (hello.go:6) MOVQ    80(SP), BP
        0x0081 00129 (hello.go:6) ADDQ    $88, SP
        0x0085 00133 (hello.go:6) RET
        0x0086 00134 (hello.go:6) NOP
        0x0086 00134 (hello.go:5) PCDATA  $1, $-1
        0x0086 00134 (hello.go:5) PCDATA  $0, $-2
        0x0086 00134 (hello.go:5) CALL    runtime.morestack_noctxt(SB)
        0x008b 00139 (hello.go:5) PCDATA  $0, $-1
        0x008b 00139 (hello.go:5) JMP     0
        0x0000 65 48 8b 0c 25 28 00 00 00 48 8b 89 00 00 00 00  eH..%(...H......
        0x0010 48 3b 61 10 76 70 48 83 ec 58 48 89 6c 24 50 48  H;a.vpH..XH.l$PH
        0x0020 8d 6c 24 50 0f 57 c0 0f 11 44 24 40 48 8d 05 00  .l$P.W...D$@H...
        0x0030 00 00 00 48 89 44 24 40 48 8d 05 00 00 00 00 48  ...H.D$@H......H
        0x0040 89 44 24 48 48 8b 05 00 00 00 00 48 8d 0d 00 00  .D$HH......H....
        0x0050 00 00 48 89 0c 24 48 89 44 24 08 48 8d 44 24 40  ..H..$H.D$.H.D$@
        0x0060 48 89 44 24 10 48 c7 44 24 18 01 00 00 00 48 c7  H.D$.H.D$.....H.
        0x0070 44 24 20 01 00 00 00 e8 00 00 00 00 48 8b 6c 24  D$ .........H.l$
        0x0080 50 48 83 c4 58 c3 e8 00 00 00 00 e9 70 ff ff ff  PH..X.......p...
        rel 2+0 t=25 type.string+0
        rel 2+0 t=25 type.*os.File+0
        rel 12+4 t=17 TLS+0
        rel 47+4 t=16 type.string+0
        rel 59+4 t=16 ""..stmp_0+0
        rel 71+4 t=16 os.Stdout+0
        rel 78+4 t=16 go.itab.*os.File,io.Writer+0
        rel 120+4 t=8 fmt.Fprintln+0
        rel 135+4 t=8 runtime.morestack_noctxt+0

可以发现存在FUNCDATA和PCDATA这类与x86-64机器平台对应不上的抽象指令集。这两个指令包含了用于垃圾回收（GC）的信息。

然后反向将程序反汇编出Go汇编，观察实际二进制指令。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
go tool objdump -s main.main hello.exe
TEXT main.main(SB) hello.go
  hello.go:5            0x4a79e0                65488b0c2528000000      MOVQ GS:0x28, CX
  hello.go:5            0x4a79e9                488b8900000000          MOVQ 0(CX), CX
  hello.go:5            0x4a79f0                483b6110                CMPQ 0x10(CX), SP
  hello.go:5            0x4a79f4                7670                    JBE 0x4a7a66
  hello.go:5            0x4a79f6                4883ec58                SUBQ $0x58, SP
  hello.go:5            0x4a79fa                48896c2450              MOVQ BP, 0x50(SP)
  hello.go:5            0x4a79ff                488d6c2450              LEAQ 0x50(SP), BP
  hello.go:6            0x4a7a04                0f57c0                  XORPS X0, X0
  hello.go:6            0x4a7a07                0f11442440              MOVUPS X0, 0x40(SP)
  hello.go:6            0x4a7a0c                488d056db70000          LEAQ runtime.rodata+45440(SB), AX
  hello.go:6            0x4a7a13                4889442440              MOVQ AX, 0x40(SP)
  hello.go:6            0x4a7a18                488d05a9750400          LEAQ sync/atomic.CompareAndSwapUintptr.args_stackmap+192(SB), AX
  hello.go:6            0x4a7a1f                4889442448              MOVQ AX, 0x48(SP)
  print.go:274          0x4a7a24                488b05fdfb0b00          MOVQ os.Stdout(SB), AX
  print.go:274          0x4a7a2b                488d0dc6890400          LEAQ go.itab.*os.File,io.Writer(SB), CX
  print.go:274          0x4a7a32                48890c24                MOVQ CX, 0(SP)
  print.go:274          0x4a7a36                4889442408              MOVQ AX, 0x8(SP)
  print.go:274          0x4a7a3b                488d442440              LEAQ 0x40(SP), AX
  print.go:274          0x4a7a40                4889442410              MOVQ AX, 0x10(SP)
  print.go:274          0x4a7a45                48c744241801000000      MOVQ $0x1, 0x18(SP)
  print.go:274          0x4a7a4e                48c744242001000000      MOVQ $0x1, 0x20(SP)
  print.go:274          0x4a7a57                e8e499ffff              CALL fmt.Fprintln(SB)
  hello.go:6            0x4a7a5c                488b6c2450              MOVQ 0x50(SP), BP
  hello.go:6            0x4a7a61                4883c458                ADDQ $0x58, SP
  hello.go:6            0x4a7a65                c3                      RET
  hello.go:5            0x4a7a66                e835c7fbff              CALL runtime.morestack_noctxt(SB)
  hello.go:5            0x4a7a6b                e970ffffff              JMP main.main(SB)

可以发现指令集和寄存器的使用都已经非常贴近实际的AMD64平台了。（当然实际上还不是能完全对的上具体寄存器，但是指令集已经很接近了）

常量解析

Go汇编器对于常量表达式的解析和原生Plan9还是有区别的。Go汇编器遵循Go语言自己的表达式优先级，而非C语言风格的优先级。

比如3&1<<2在Go中会解析为(3&1)<<2，而不是3&(1<<2)。

伪寄存器

Go汇编中预定义了4个伪寄存器。这四个是无关机器平台的，任意架构的都会用上。

  1. FP：帧指针（Frame Pointer），用于指向函数帧与传参。
  2. PC：程序计数器（Program Counter），控制程序走向，跳转与分支（就是常见的eip或rip）。
  3. SB：静态栈底指针（Static Base pointer），指向全局变量。
  4. SP：栈指针（Stack Pointer），指向局部栈帧的最高地址处。

FP

FP寄存器是一个指向函数参数的栈帧指针，通常用FP加上一个偏移来访问函数的参数和返回值。例如用0(FP)访问第一个参数，8(FP)访问第二个参数（在64位机器上，偏移是默认8字节）。但是为了便于阅读，生成Go汇编时还需要再前面加上参数的名称：first_arg+0(FP)、second_arg+8(FP)，其中+并没有任何意义，只用作分隔符。汇编器强制这种形式，拒绝一般的0(FP)和8(FP)。值得一提的是FP总是一个伪寄存器。

  1. 根据官方博客，在正向生成代码的时候FP会用上，反编译后就会变成具体的基于架构的寄存器了。
  2. 实际上暂时还没碰见，遇到的都是诸如AX，CX等偏具体的寄存器名了。

SB

SB可以被看作内存段的起点，所以符号foo(SB)就是foo所在地址。这种形式被用于命名全局函数和数据。通过添加<>到名字上，比如foo<>(SB)，会让此名字仅在此源代码文件中可见，相当于C语言中的static声明。在名字上添加偏移代表了相应偏移的地址位，比如foo+4(SB)代表了foo后跨过四字节的位置。

  1. 比如CALL fmt.Fprintln(SB)就是调用fmt.Println函数，其中就是用SB寄存器指向全局函数的。
  2. 未strip的Go程序用go tool objdump反汇编后还会保留此类信息。

SP

SP是虚拟栈指针。指向局部帧变量和准备用于函数调用的参数。它指向局部栈帧的最高地址位，所以任何偏移都应该是取负数地址，[-framesize, 0)。比如x-8(SP)，y-4(SP)。

若某些架构上有名为SP的指针，要注意区分。有名称前缀的是Go中的虚拟栈指针，比如x-8(SP)；而-8(SP)则是硬件上的SP指针。

不用太纠结于此，反正知道在AMD64上，SP和真正的寄存器是不一样的。比如我通过用IDA反汇编得知实际上使用的是rax寄存器。

所有用户定义的符号都会被写成SB和FP加偏移的形式，而SP寄存器包含了FP的功能。 其实在我看到的x86下的Go汇编中，编译器一般不使用FP寄存器， 而是使用SP来访问局部变量和函数参数。

PC

PC为程序计数器，指向当前程序的执行位置，在x86中它是eip或rip寄存器。

绝对跳转和函数调用可以指向符号，比如foo(SB)，但是不能带有偏移，比如foo+4(SB)。

函数与数据定义

函数

与其他风格的汇编类似，Go汇编也需要为函数或数据指明它们所在的节，如TEXT节或DATA节。但是Go汇编在定义每个函数或变量时都要明确指定：

1
2
3
4
5
TEXT runtime.profileloop(SB),NOSPLIT,$8
	MOVQ	$runtime·profileloop1(SB), CX
	MOVQ	CX, 0(SP)
	CALL	runtime·externalthreadhandler(SB)
	RET

TEXT指令后面分别是函数名、函数标记（flags）和帧大小（字节）。通常情况下，帧大小后面跟着一个参数大小，并用负号分隔，如$24-8，其中帧大小为24字节，单个参数大小为8字节。由于这里使用了NOSPLIT函数标示，可以不提供参数大小。有时候函数没有栈帧，可以将帧大小设置为0。同样的，有些函数也没有参数和返回值，可以将参数大小设置为0。在函数的最后，必须是短跳转指令或RET指令，如果不是，Go链接器会在函数后面添加一个跳转到该函数自身的指令。

全局变量

全局数据的定义可以使用DATA指令配合GLOBL指令：

1
DATA	symbol+offset(SB)/width, value

其中offset为相对于symbol的偏移，width为数据宽度，value为数据的值。

这样就会分配相应要求的内存空间并存储数据。

然后再使用GLOBL指令来声明此变量为全局的。

1
GLOBL 名称(SB), 标识, 大小（字节）

举例：

1
2
3
4
5
6
7
DATA divtab<>+0x00(SB)/4, $0xf4f8fcff
DATA divtab<>+0x04(SB)/4, $0xe6eaedf0
...
DATA divtab<>+0x3c(SB)/4, $0x81828384
GLOBL divtab<>(SB), RODATA, $64

GLOBL runtime·tlsoffset(SB), NOPTR, $4

就是从divtab为起点开始存储4字节4字节的具体数据，一共64字节，然后声明全局变量divtab，且其属性是RODATA，大小是64字节。

同时还声明了另一个全局变量，4字节大小，没有指针。未用DATA初始化，所以默认为0。

标识列表（未翻译）

  • NOPROF = 1
    (For TEXT items.) Don’t profile the marked function. This flag is deprecated.
  • DUPOK = 2
    It is legal to have multiple instances of this symbol in a single binary. The linker will choose one of the duplicates to use.
  • NOSPLIT = 4
    (For TEXT items.) Don’t insert the preamble to check if the stack must be split. The frame for the routine, plus anything it calls, must fit in the spare space remaining in the current stack segment. Used to protect routines such as the stack splitting code itself.
  • RODATA = 8
    (For DATA and GLOBL items.) Put this data in a read-only section.
  • NOPTR = 16
    (For DATA and GLOBL items.) This data contains no pointers and therefore does not need to be scanned by the garbage collector.
  • WRAPPER = 32
    (For TEXT items.) This is a wrapper function and should not count as disabling recover.
  • NEEDCTXT = 64
    (For TEXT items.) This function is a closure so it uses its incoming context register.
  • LOCAL = 128
    This symbol is local to the dynamic shared object.
  • TLSBSS = 256
    (For DATA and GLOBL items.) Put this data in thread local storage.
  • NOFRAME = 512
    (For TEXT items.) Do not insert instructions to allocate a stack frame and save/restore the return address, even if this is not a leaf function. Only valid on functions that declare a frame size of 0.
  • TOPFRAME = 2048
    (For TEXT items.) Function is the outermost frame of the call stack. Traceback should stop at this function.

使用Go类型/常量

If a package has any .s files, then go build will direct the compiler to emit a special header called go_asm.h, which the .s files can then #include. The file contains symbolic #define constants for the offsets of Go struct fields, the sizes of Go struct types, and most Go const declarations defined in the current package. Go assembly should avoid making assumptions about the layout of Go types and instead use these constants. This improves the readability of assembly code, and keeps it robust to changes in data layout either in the Go type definitions or in the layout rules used by the Go compiler.

在Go汇编中，常量是const_name的形式。比如在一般Go语言中声明const bufSize = 1024，那么汇编码中可以通过const_bufSize来获取。

结构体的成员偏移则是type_field。结构体的大小是type_size。比如考虑一下结构体：

1
2
3
4
type reader struct {
	buf [bufsize]byte
	r 	int 
}

通过reader_size获得大小，reader_buf和reader_r获得结构体成员偏移。

所以如果R1寄存器指向了reader结构体头，则reader_buf(R1)即可指向成员buf。

Runtime Coordination

程序运行时的垃圾回收问题。略。

具体架构细节

完全列出某个架构所有指令是不现实的。所以为了研究什么指令是用于什么架构的，比如说ARM架构，看源码src/cmd/internal/obj/arm库文件即可。

1
2
3
4
5
6
7
const (
	AAND = obj.ABaseARM + obj.A_ARCHSPECIFIC + iota
	AEOR
	ASUB
	ARSB
	AADD
	...

其他架构同理。

值得注意的是，数据流是从左往右的，即MOVQ $0, CX将清空CX。

32-bit Intel 386

指向结构体g（某任意结构体）的运行时指针会被一个没被用上的寄存器维护。在运行库中，汇编码可以包含go_tls.h，这个库定义了基于OS和架构的宏get_tls，用于获取这个寄存器。get_tls有一个形参，此参便是将要获得g指针的寄存器。

比如，通过CX，BX寄存器获取g和其子成员m的指针

1
2
3
4
5
6
#include "go_tls.h"
#include "go_asm.h"

get_tls(CX)
MOVL g(CX), AX
MOVL g_m(AX), BX

get_tls宏在AMD64架构上也被定义了。

取地址偏移：

  1. (DI)(BX*2)是 DI+BX*2的地址处
  2. 64(DI)(BX*2)是DI+BX*2+64。只能接受1，2，4，8的乘法。

When using the compiler and assembler’s -dynlink or -shared modes, any load or store of a fixed memory location such as a global variable must be assumed to overwrite CX. Therefore, to be safe for use with these modes, assembly sources should typically avoid CX except between memory references.

64bit Intel 386 （AMD64）

除了使用MOVQ而非MOVL以外基本没变。

BP寄存器是被调用函数恢复的。汇编器会自动添加BP平衡指令，如果当前栈帧大于等于0。使用BP寄存器作为一般用途寄存器是被允许的，但不建议。

其他RISC架构

略，详见官方博客。

Unsupported opcodes

稍微讲了下开发者面对Go汇编器不认识的机器平台指令时的处理方式。

The assemblers are designed to support the compiler so not all hardware instructions are defined for all architectures: if the compiler doesn’t generate it, it might not be there. If you need to use a missing instruction, there are two ways to proceed. One is to update the assembler to support that instruction, which is straightforward but only worthwhile if it’s likely the instruction will be used again. Instead, for simple one-off cases, it’s possible to use the BYTE and WORD directives to lay down explicit data into the instruction stream within a TEXT. Here’s how the 386 runtime defines the 64-bit atomic load function.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// uint64 atomicload64(uint64 volatile* addr);
// so actually
// void atomicload64(uint64 *res, uint64 volatile *addr);
TEXT runtime·atomicload64(SB), NOSPLIT, $0-12
	MOVL	ptr+0(FP), AX
	TESTL	$7, AX
	JZ	2(PC)
	MOVL	0, AX // crash with nil ptr deref
	LEAL	ret_lo+4(FP), BX
	// MOVQ (%EAX), %MM0
	BYTE $0x0f; BYTE $0x6f; BYTE $0x00
	// MOVQ %MM0, 0(%EBX)
	BYTE $0x0f; BYTE $0x7f; BYTE $0x03
	// EMMS
	BYTE $0x0F; BYTE $0x77
	RET

AMD64下Go函数调用底层分析

基于 The Go low-level calling convention on x86-64 · dr knz @ work (dr-knz.net) 配合高版本分析

参数/返回值/序列调用

参数和返回值

1
2
3
func EmptyFunc() {} // 无参无返回
func FuncConst() int { return 123 } // 无参返回常量
func FuncAdd(x, y, z int) int { return x + y - z } // 3int返回1int
EmptyFunc
1
c3                      RET

直接返回

FuncConst
1
2
48c74424087b000000      MOVQ $0x7b, 0x8(SP)
c3                      RET

小于SP地址的是局部栈帧（见上文），0x8(SP)则是栈帧外边的第2个QWORD，将会作为此函数的返回值。（第一个QWORD0(SP)是CALL指令压进栈的返回地址）

FuncAdd
1
2
3
4
5
488b442408              MOVQ 0x8(SP), AX
4803442410              ADDQ 0x10(SP), AX
482b442418              SUBQ 0x18(SP), AX
4889442420              MOVQ AX, 0x20(SP)
c3                      RET

0x8(SP)等2个参数皆是局部栈帧外部，高地址位传来的的参数。操作在AX寄存器上直接完成，没有利用任何局部变量。

可见传参与返回全是基于栈的。

函数调用

1
func DoCallAdd() int { return FuncAdd(1, 2, 3) }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
65488b0c2528000000      MOVQ GS:0x28, CX
488b8900000000          MOVQ 0(CX), CX
483b6110                CMPQ 0x10(CX), SP
764f                    JBE 0x4a7b05

4883ec30                SUBQ $0x30, SP ; 分配栈空间
; BP链表
48896c2428              MOVQ BP, 0x28(SP)
488d6c2428              LEAQ 0x28(SP), BP

48c744243800000000      MOVQ $0x0, 0x38(SP) ; （未优化导致的冗余代码，用于清空返回值所在地）
; 函数调用与返回
48c7042401000000        MOVQ $0x1, 0(SP)	; 第一个参数
48c744240802000000      MOVQ $0x2, 0x8(SP)  ; 2
48c744241003000000      MOVQ $0x3, 0x10(SP) ; 3
e894ffffff              CALL main.FuncAdd(SB)
488b442418              MOVQ 0x18(SP), AX   ; 得到返回值，放到AX上
4889442420              MOVQ AX, 0x20(SP)   ; 再将AX上的值放到更高位的栈上。（未优化时的代码）
4889442438              MOVQ AX, 0x38(SP)   ; 0x38将是正式返回给调用者函数的返回值。
488b6c2428              MOVQ 0x28(SP), BP   ; 获得旧BP，得到调用者函数的栈底；弹出被调用函数的栈帧
4883c430                ADDQ $0x30, SP      ; 回收栈空间
c3                      RET
e896c6fbff              CALL runtime.morestack_noctxt(SB)
eb94                    JMP main.DoCallAdd(SB)

在函数前的检查结束后，代码中心便是具体调用。

1
2
3
4
5
48c7042401000000        MOVQ $0x1, 0(SP)	; 第一个参数
48c744240802000000      MOVQ $0x2, 0x8(SP)  ; 2
48c744241003000000      MOVQ $0x3, 0x10(SP) ; 3
e894ffffff              CALL main.FuncAdd(SB)
488b442418              MOVQ 0x18(SP), AX   ; 得到返回值

当然，为了给传参预留空间，调用者函数需要分配与回收一段栈空间。

1
2
3
4883ec30                SUBQ $0x30, SP
; .......
4883c430                ADDQ $0x30, SP

同时，因为Go有Panic机制，出错时要有栈回溯的能力，所以必须存储入口时栈指针和调用者栈指针的差异。

1
2
3
4
5
6
7
8
; Store the frame pointer of the caller into a known location in
; the current activation record.
; 在当前记录中将调用者（main.main函数调用了DoCallAdd函数）的栈底指针BP存储在一个已知位置上
48896c2428              MOVQ BP, 0x28(SP)
; Store the address of the copy of the parent frame pointer
; into the new frame pointer.
; 将父栈底指针的地址存到现在新的栈底指针中
488d6c2428              LEAQ 0x28(SP), BP ; 即 BP = SP + 0x28

大概栈中的样子：

寄存器地址指向 内存内容 描述
main.main BP main函数维护的BP位置
…. 预留的栈空间
main.main SP(before call) 调用前一刻SP所处位置
SP*(called) addr 调用后，压栈了下一条指令的地址；SP* = SP - 8
BP* BP 位于SP**+0x28处，恰好在返回地址下方；新旧BP构成了链表
SP** SP** = SP* - 0x30，DoCallAdd()函数内预留栈空间

这个就是用于异常处理的，跟SEH原理很类似。通过链表进行回溯。一旦出错，新BP立刻取内存内的值，获得旧BP的值，从而相对上将现在错误函数的栈帧全部弹掉。

Go还有“小代码”优化。即程序一开始只会被分配很小的一块内存区域。所以只要是需要一定栈空间的函数，都会首先检查现在Go routine分配的够不够。通过将现在的SP指针和Go routine最低水位线对比来实现。

1
2
3
4
5
6
7
65488b0c2528000000      MOVQ GS:0x28, CX  
488b8900000000          MOVQ 0(CX), CX     
483b6110                CMPQ 0x10(CX), SP
764f                    JBE 0x4a7b05

e896c6fbff              CALL runtime.morestack_noctxt(SB)
eb94                    JMP main.DoCallAdd(SB)

若不够，则会CALL runtime.morestack_noctxt(SB)来分配部分空间，然后再次跳回函数顶部，如此循环直到内存空间充足。

（补充）C/C++中的异常处理

JL Schilling - Optimizing away C++ exception handling - ACM SIGPLAN Notices, 1998

被调用函数是否拥有保留寄存器

其它语言中，可能会处于优化的目的将一些经常用到的值直接保留在寄存器上，而不会再压入栈中。Go语言中，却总是会将变量入栈。

1
2
3
4
5
func Intermediate() int {
  x := Other()
  x += Other()
  return x
}
1
2
3
4
5
6
7
8
9
10
Intermediate:
  [...]
  0x4806dd              e8ceffffff              CALL src.Other(SB)
  0x4806e2              488b0424                MOVQ 0(SP), AX
  0x4806e6              4889442408              MOVQ AX, 0x8(SP)
  0x4806eb              e8c0ffffff              CALL src.Other(SB)
  0x4806f0              488b442408              MOVQ 0x8(SP), AX
  0x4806f5              48030424                ADDQ 0(SP), AX
  0x4806f9              4889442420              MOVQ AX, 0x20(SP)
  [...]

指针花销和接口

Go同时实现了指针类型，以及拥有vtable的接口类型。

只用一个QWORD的指针

1
func UsePtr(x *int) int { return *x } // 解引用
1
2
3
4
5
UsePtr:
  0x480630              488b442408              MOVQ 0x8(SP), AX  ; load x
  0x480635              488b00                  MOVQ 0(AX), AX    ; load *x
  0x480638              4889442410              MOVQ AX, 0x10(SP) ; return *x
  0x48063d              c3                      RET

所以指针大小跟一个QWORD一样。

1
2
3
var x int
func RetPtr() *int { return &x }
func NilPtr() *int { return nil }
1
2
3
4
5
6
7
RetPtr:
  0x480650              488d0581010c00          LEAQ src.x(SB), AX  ; compute &x
  0x480657              4889442408              MOVQ AX, 0x8(SP)    ; return &x
  0x48065c              c3                      RET
NilPtr:
  0x480660              48c744240800000000      MOVQ $0x0, 0x8(SP)  ; return 0
  0x480669              c3                      RET

使用2个QWORD的接口（非空接口）

1
2
type Foo interface{ foo() }
func InterfaceNil() Foo { return nil }
1
2
3
4
InterfaceNil:
  0x4805b0              0f57c0                  XORPS X0, X0
  0x4805b3              0f11442408              MOVUPS X0, 0x8(SP)
  0x4805b8              c3                      RET

使用的是一个xmm寄存器，128位，2个QWORD

1
func InterfacePass(x Foo) Foo { return x }
1
2
3
4
5
6
7
4.go:11               0x491fa0                0f57c0                  XORPS X0, X0
4.go:11               0x491fa3                0f11442418              MOVUPS X0, 0x18(SP)
4.go:11               0x491fa8                488b442410              MOVQ 0x10(SP), AX
4.go:11               0x491fad                488b4c2408              MOVQ 0x8(SP), CX
4.go:11               0x491fb2                48894c2418              MOVQ CX, 0x18(SP)
4.go:11               0x491fb7                4889442420              MOVQ AX, 0x20(SP)
4.go:11               0x491fbc                c3                      RET

虽然只有1个参数，但是复制了2个QWORD。

使用2或3个QWORD的字符串或切片

字符串

string由2个QWORD组成

1
2
3
4
type StringHeader struct {
	Data uintptr	// 指向字符串地址的指针
	Len  int        // 长度
}
切片

slice由3个QWORD组成

1
2
3
4
5
type SliceHeader struct {
	Data uintptr
	Len  int
	Cap  int
}

与切片的结构体相比，字符串少了一个表示容量的 Cap 字段，因为字符串作为只读的类型，我们并不会直接向字符串直接追加元素改变其本身的内存空间，所有在字符串上执行的写入操作实际都是通过拷贝实现的。

构造接口值

  1. 刚刚入门Go语言，接口的意义和实现花了我挺久时间研究。
  2. 基于版本1.16.6。据说与老版本go1.10稍有差异
通过结构指针构造
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import (
	"fmt"
)

// 实现say接口
type Sayer interface {
	say()
}

// cat结构体
type cat struct {
	id int
}

// 定义指向cat结构体指针的方法
// 方法定义请看https://www.runoob.com/go/go-method.html
func (m *cat) say() {
	fmt.Println("meow")
}

// 全局变量，避免堆分配
var janny cat

// 通过指针构造一个Sayer接口
func MakeInterface1() Sayer { return &janny }

func main() {
	MakeInterface1()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
TEXT main.MakeInterface1(SB) C:/Users/任昊/Desktop/SSTudy/Go/Blog2/5.go
0x4a7b20                4883ec10                SUBQ $0x10, SP   	
0x4a7b24                48896c2408              MOVQ BP, 0x8(SP)
0x4a7b29                488d6c2408              LEAQ 0x8(SP), BP
0x4a7b2e                0f57c0                  XORPS X0, X0
0x4a7b36                488d052b311000          LEAQ main.janny(SB), AX   ; AX指向janny结构体
0x4a7b3d                48890424                MOVQ AX, 0(SP)            ; 
0x4a7b41                488d0d708a0400          LEAQ go.itab.*main.cat,main.Sayer(SB), CX ; CX指向Sayer
0x4a7b48                48894c2418              MOVQ CX, 0x18(SP)         ; +0x18偏移，vtable
0x4a7b4d                4889442420              MOVQ AX, 0x20(SP)         ; +0x20偏移，指向具体结构体janny
0x4a7b52                488b6c2408              MOVQ 0x8(SP), BP
0x4a7b57                4883c410                ADDQ $0x10, SP
0x4a7b5b                c3                      RET

通过

1
2
0x4a7b48                48894c2418              MOVQ CX, 0x18(SP)         ; +0x18偏移，vtable
0x4a7b4d                4889442420              MOVQ AX, 0x20(SP)         ; +0x20偏移，指向具体结构体

可以得知创建的接口中，第一个QWORD指向了vtable，第二个则指向具体结构体。

通过结构构造

直接分析新版本底层。The Go low-level calling convention on x86-64 (updated) - What’s new in 2020 and in Go 1.15 · dr knz @ work (dr-knz.net)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package main

import (
	"fmt"
)

// 实现say接口
type Sayer interface {
	say()
}

// cat结构体
type cat struct {
	id int
}

// 定义cat结构的方法
// 方法定义请看https://www.runoob.com/go/go-method.html
func (m cat) say() {
	fmt.Println("meow")
}

// 全局变量，避免堆分配
var janny cat

// 通过构造一个Sayer接口
func MakeInterface2() Sayer { return janny }

func main() {
	MakeInterface2()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
6.go:27               0x4a7b20                65488b0c2528000000      MOVQ GS:0x28, CX
6.go:27               0x4a7b29                488b8900000000          MOVQ 0(CX), CX
6.go:27               0x4a7b30                483b6110                CMPQ 0x10(CX), SP
6.go:27               0x4a7b34                764b                    JBE 0x4a7b81
6.go:27               0x4a7b36                4883ec20                SUBQ $0x20, SP
6.go:27               0x4a7b3a                48896c2418              MOVQ BP, 0x18(SP)
6.go:27               0x4a7b3f                488d6c2418              LEAQ 0x18(SP), BP
6.go:27               0x4a7b44                0f57c0                  XORPS X0, X0
6.go:27               0x4a7b47                0f11442428              MOVUPS X0, 0x28(SP)
6.go:27               0x4a7b4c                488b0515411000          MOVQ main.janny(SB), AX
6.go:27               0x4a7b53                48890424                MOVQ AX, 0(SP)
6.go:27               0x4a7b57                e8442df6ff              CALL runtime.convT64(SB)
6.go:27               0x4a7b5c                488b442408              MOVQ 0x8(SP), AX
6.go:27               0x4a7b61                4889442410              MOVQ AX, 0x10(SP)
6.go:27               0x4a7b66                488d0dab8a0400          LEAQ go.itab.main.cat,main.Sayer(SB), CX
6.go:27               0x4a7b6d                48894c2428              MOVQ CX, 0x28(SP)
6.go:27               0x4a7b72                4889442430              MOVQ AX, 0x30(SP)
6.go:27               0x4a7b77                488b6c2418              MOVQ 0x18(SP), BP
6.go:27               0x4a7b7c                4883c420                ADDQ $0x20, SP
6.go:27               0x4a7b80                c3                      RET
6.go:27               0x4a7b81                e81ac6fbff              CALL runtime.morestack_noctxt(SB)
6.go:27               0x4a7b86                eb98                    JMP main.MakeInterface2(SB)

通过直接传结构体构造接口，代码量会大不少。因为它会再调用runtime.convT64(SB)函数。

去掉前言和结尾，得到核心块

1
2
3
4
5
6
7
8
6.go:27               0x4a7b4c                488b0515411000          MOVQ main.janny(SB), AX
6.go:27               0x4a7b53                48890424                MOVQ AX, 0(SP)
6.go:27               0x4a7b57                e8442df6ff              CALL runtime.convT64(SB)
6.go:27               0x4a7b5c                488b442408              MOVQ 0x8(SP), AX
6.go:27               0x4a7b61                4889442410              MOVQ AX, 0x10(SP)
6.go:27               0x4a7b66                488d0dab8a0400          LEAQ go.itab.main.cat,main.Sayer(SB), CX
6.go:27               0x4a7b6d                48894c2428              MOVQ CX, 0x28(SP)
6.go:27               0x4a7b72                4889442430              MOVQ AX, 0x30(SP)

即会调用runtime.convT64(janny)来获得一个裸指针，然后调用者函数再将Sayer vtable和它接在一起。

除了runtime.convT64以外还有好几个相似函数，用于不同大小的数据和类型。

  1. convT2I16, convT2I32, convT2I64 for “small” types;
  2. convT2Istring, convT2Islice for string and slice types;
  3. convT2Inoptr for structs that do not contain pointers;
  4. convT2I for the general case.

其中此示例代码如果是老版本编译，会遇到convT2I64函数，现在处于优化基本都用convT64I这个泛型函数了。

convT64的用途就是调用堆分配器，分配一块空间来获取对象的一个副本，返回一个指针。

空结构体的接口

根据实践发现，空结构体的接口其实就是空接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import _ "fmt"

type Foo interface{ foo() }

type empty struct{}

func (empty) foo() {}

var x empty

func MakeInterface3() Foo { return x }

func main() {
	MakeInterface3()
}

其中的empty结构体，没有定义成员，其方法也是没有任何操作。

1
2
3
4
5
6
7
7.go:13               0x491fc0                0f57c0                  XORPS X0, X0  
7.go:13               0x491fc3                0f11442408              MOVUPS X0, 0x8(SP)
7.go:13               0x491fc8                488d0549500400          LEAQ go.itab.main.empty,main.Foo(SB), AX
7.go:13               0x491fcf                4889442408              MOVQ AX, 0x8(SP)
7.go:13               0x491fd4                488d0505500f00          LEAQ runtime.zerobase(SB), AX
7.go:13               0x491fdb                4889442410              MOVQ AX, 0x10(SP)
7.go:13               0x491fe0                c3                      RET

而用interface{}明确声明的空接口，编译后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import "fmt"
// 空接口
type Foo interface{}

type empty struct{}

var x empty

func MakeInterface3() Foo { return x }

func main() {
	// 定义一个空接口x
	x := MakeInterface3()
	s := "pprof.cn"
	x = s
	fmt.Printf("type:%T value:%v\n", x, x)
	i := 100
	x = i
	fmt.Printf("type:%T value:%v\n", x, x)
	b := true
	x = b
	fmt.Printf("type:%T value:%v\n", x, x)
}

1
2
3
4
5
6
7
8
; MakeInterface3
7.go:11               0x4a92a0                0f57c0                  XORPS X0, X0
7.go:11               0x4a92a3                0f11442408              MOVUPS X0, 0x8(SP)
7.go:11               0x4a92a8                488d05d1000100          LEAQ type.*+62336(SB), AX
7.go:11               0x4a92af                4889442408              MOVQ AX, 0x8(SP)
7.go:11               0x4a92b4                488d05254b1000          LEAQ runtime.zerobase(SB), AX
7.go:11               0x4a92bb                4889442410              MOVQ AX, 0x10(SP)
7.go:11               0x4a92c0                c3                      RET

两者汇编基本一致。需要知道的就是其第二个QWORD都是runtime.zerobase函数地址，且由于无需任何函数调用，所以没有用于检查栈帧的函数前言和尾部。

error是一种接口类型

1
2
3
4
5
6
7
8
9
10
package main

func Simple1() int          { return 123 }
func Simple2() (int, error) { return 123, nil }

func main() {
	Simple1()
	Simple2()
}

Simple1()

1
2
3
8.go:3                0x462720                48c744240800000000      MOVQ $0x0, 0x8(SP)
8.go:3                0x462729                48c74424087b000000      MOVQ $0x7b, 0x8(SP)
8.go:3                0x462732                c3                      RET

Simple2()

1
2
3
4
5
6
7
8.go:4                0x462740                48c744240800000000      MOVQ $0x0, 0x8(SP)
8.go:4                0x462749                0f57c0                  XORPS X0, X0
8.go:4                0x46274c                0f11442410              MOVUPS X0, 0x10(SP)
8.go:4                0x462751                48c74424087b000000      MOVQ $0x7b, 0x8(SP)
8.go:4                0x46275a                0f57c0                  XORPS X0, X0
8.go:4                0x46275d                0f11442410              MOVUPS X0, 0x10(SP)
8.go:4                0x462762                c3                      RET

可以发现它第二个参数使用了xmm寄存器，是接口形式。

计算错误

便于观察，故错误抛出是被定义为全局变量了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import (
	"errors"
	"fmt"
)

var errDivByZero = errors.New("can't divide by zero")

func Compute(x, y float64) (float64, error) {
	if y == 0 {
		return 0, errDivByZero
	}
	return x / y, nil
}

func main() {
	fmt.Println(Compute(1, 0))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
; x : 0x8(SP)
; y : 0x10(SP)
9.go:10               0x4a7b20                0f57c0                  XORPS X0, X0              ; xmm0 = 0
9.go:10               0x4a7b23                f20f11442418            MOVSD_XMM X0, 0x18(SP) 
9.go:10               0x4a7b29                0f57c9                  XORPS X1, X1
9.go:10               0x4a7b2c                0f114c2420              MOVUPS X1, 0x20(SP)

9.go:11               0x4a7b31                f20f104c2410            MOVSD_XMM 0x10(SP), X1    ; y -> xmm1寄存器
9.go:11               0x4a7b37                660f2ec8                UCOMISD X0, X1 ; Unordered Compare Scalar Double 相互比较2个寄存器低位的浮点数，然后设置EFLAGS; is y == 0?
9.go:11               0x4a7b3b                7524                    JNE 0x4a7b61 ; if y != 0: jmp
 
9.go:11               0x4a7b3d                7b03                    JNP 0x4a7b42 ; if y not parity（浮点数比较，处于精度考虑出现的）
9.go:11               0x4a7b3f                90                      NOPL
9.go:11               0x4a7b40                eb1f                    JMP 0x4a7b61
; y == 0，error
9.go:12               0x4a7b42                f20f11442418            MOVSD_XMM X0, 0x18(SP)
9.go:12               0x4a7b48                488b0501030c00          MOVQ main.errDivByZero(SB), AX
9.go:12               0x4a7b4f                488b0d02030c00          MOVQ main.errDivByZero+8(SB), CX
9.go:12               0x4a7b56                4889442420              MOVQ AX, 0x20(SP) ;
9.go:12               0x4a7b5b                48894c2428              MOVQ CX, 0x28(SP) ; 2个QWORD
9.go:12               0x4a7b60                c3                      RET
; y != 0
9.go:14               0x4a7b61                f20f10442408            MOVSD_XMM 0x8(SP), X0
9.go:14               0x4a7b67                f20f5e442410            DIVSD 0x10(SP), X0
9.go:14               0x4a7b6d                f20f11442418            MOVSD_XMM X0, 0x18(SP)
9.go:14               0x4a7b73                0f57c0                  XORPS X0, X0
9.go:14               0x4a7b76                0f11442420              MOVUPS X0, 0x20(SP)
9.go:14               0x4a7b7b                c3                      RET
1
2
3
4
9.go:12               0x4a7b48                488b0501030c00          MOVQ main.errDivByZero(SB), AX
9.go:12               0x4a7b4f                488b0d02030c00          MOVQ main.errDivByZero+8(SB), CX
9.go:12               0x4a7b56                4889442420              MOVQ AX, 0x20(SP) ;
9.go:12               0x4a7b5b                48894c2428              MOVQ CX, 0x28(SP) ; 2个QWORD

一样。

以下是更一般的情况。即错误抛出通过函数实时调用，所以会产生复杂的函数前言和尾声。

1
2
3
4
5
6
func Compute(x, y float64) (float64, error) {
  if y == 0 {
    return 0, fmt.Errorf("can't divide %f by zero", x)
  }
  return x / y, nil
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
; x = 0x90(SP)
; y = 0x98(SP)
; 序言
10.go:10              0x4a97c0                65488b0c2528000000      MOVQ GS:0x28, CX
10.go:10              0x4a97c9                488b8900000000          MOVQ 0(CX), CX
10.go:10              0x4a97d0                488d4424f8              LEAQ -0x8(SP), AX
10.go:10              0x4a97d5                483b4110                CMPQ 0x10(CX), AX
10.go:10              0x4a97d9                0f8682010000            JBE 0x4a9961
10.go:10              0x4a97df                4881ec88000000          SUBQ $0x88, SP
10.go:10              0x4a97e6                4889ac2480000000        MOVQ BP, 0x80(SP)
10.go:10              0x4a97ee                488dac2480000000        LEAQ 0x80(SP), BP

10.go:10              0x4a97f6                0f57c0                  XORPS X0, X0
10.go:10              0x4a97f9                f20f118424a0000000      MOVSD_XMM X0, 0xa0(SP)
10.go:10              0x4a9802                0f57c9                  XORPS X1, X1
10.go:10              0x4a9805                0f118c24a8000000        MOVUPS X1, 0xa8(SP)
; if y == 0:
10.go:11              0x4a980d                f20f108c2498000000      MOVSD_XMM 0x98(SP), X1
10.go:11              0x4a9816                660f2ec8                UCOMISD X0, X1
10.go:11              0x4a981a                660f1f440000            NOPW 0(AX)(AX*1)
10.go:11              0x4a9820                0f8504010000            JNE 0x4a992a
10.go:11              0x4a9826                7b05                    JNP 0x4a982d

10.go:11              0x4a9828                e9fd000000              JMP 0x4a992a
; if y == 0:
10.go:12              0x4a982d                0f57c0                  XORPS X0, X0
10.go:12              0x4a9830                0f11442458              MOVUPS X0, 0x58(SP)
10.go:12              0x4a9835                488d442458              LEAQ 0x58(SP), AX
10.go:12              0x4a983a                4889442440              MOVQ AX, 0x40(SP)  ; 0x40(SP) = 0x58 + SP
10.go:12              0x4a983f                f20f10842490000000      MOVSD_XMM 0x90(SP), X0 ; xmm0 = x
10.go:12              0x4a9848                f20f110424              MOVSD_XMM X0, 0(SP)
10.go:12              0x4a984d                e84e10f6ff              CALL runtime.convT64(SB) ; convT64(x)
10.go:12              0x4a9852                488b442408              MOVQ 0x8(SP), AX
10.go:12              0x4a9857                4889442438              MOVQ AX, 0x38(SP)   ; AX = 0x38(SP) = convT64(X)
10.go:12              0x4a985c                488b4c2440              MOVQ 0x40(SP), CX   ; CX = 0x58 + SP
10.go:12              0x4a9861                8401                    TESTB AL, 0(CX)     ; test LOBYTE convT64(X), 0
10.go:12              0x4a9863                488d1596ae0000          LEAQ runtime.types+42752(SB), DX
10.go:12              0x4a986a                488911                  MOVQ DX, 0(CX)      ; 0(CX) = runtime.types+42752+SB
10.go:12              0x4a986d                488d7908                LEAQ 0x8(CX), DI ; DI = 0x8+CX
10.go:12              0x4a9871                833df855100000          CMPL $0x0, runtime.writeBarrier(SB) ; 内存屏障，不管
10.go:12              0x4a9878                7405                    JE 0x4a987f
10.go:12              0x4a987a                e9a0000000              JMP 0x4a991f ; 

10.go:12              0x4a987f                48894108                MOVQ AX, 0x8(CX) ; 0x8(CX)=convT64(X)
10.go:12              0x4a9883                eb00                    JMP 0x4a9885
10.go:12              0x4a9885                488b442440              MOVQ 0x40(SP), AX ; AX = 0x58+SP
10.go:12              0x4a988a                8400                    TESTB AL, 0(AX)
10.go:12              0x4a988c                eb00                    JMP 0x4a988e
10.go:12              0x4a988e                4889442468              MOVQ AX, 0x68(SP)
10.go:12              0x4a9893                48c744247001000000      MOVQ $0x1, 0x70(SP)
10.go:12              0x4a989c                48c744247801000000      MOVQ $0x1, 0x78(SP)
; 字符串：Can't divide...及其长度，2QWORD
; CX = 0x58+SP
10.go:12              0x4a98a5                488d0ddf8f0200          LEAQ go.string.*+16715(SB), CX
; fmt.Errorf(&string, 0x17（长度）, runtime.types+42752+SB, 1, 1)
; func Errorf(format string, a ...interface{}) error
10.go:12              0x4a98ac                48890c24                MOVQ CX, 0(SP)
10.go:12              0x4a98b0                48c744240817000000      MOVQ $0x17, 0x8(SP)
10.go:12              0x4a98b9                4889442410              MOVQ AX, 0x10(SP)
10.go:12              0x4a98be                48c744241801000000      MOVQ $0x1, 0x18(SP)
10.go:12              0x4a98c7                48c744242001000000      MOVQ $0x1, 0x20(SP)
10.go:12              0x4a98d0                e8ab4cffff              CALL fmt.Errorf(SB)
; Errorf返回一个error接口，2QWORD
10.go:12              0x4a98d5                488b442428              MOVQ 0x28(SP), AX
10.go:12              0x4a98da                488b4c2430              MOVQ 0x30(SP), CX
10.go:12              0x4a98df                4889442448              MOVQ AX, 0x48(SP)
10.go:12              0x4a98e4                48894c2450              MOVQ CX, 0x50(SP)

10.go:12              0x4a98e9                0f57c0                  XORPS X0, X0
10.go:12              0x4a98ec                f20f118424a0000000      MOVSD_XMM X0, 0xa0(SP)
10.go:12              0x4a98f5                488b442448              MOVQ 0x48(SP), AX
10.go:12              0x4a98fa                488b4c2450              MOVQ 0x50(SP), CX
10.go:12              0x4a98ff                48898424a8000000        MOVQ AX, 0xa8(SP)
10.go:12              0x4a9907                48898c24b0000000        MOVQ CX, 0xb0(SP)
; 0xa0: 0
; 0xa8,0xb0: errror接口

10.go:12              0x4a990f                488bac2480000000        MOVQ 0x80(SP), BP
10.go:12              0x4a9917                4881c488000000          ADDQ $0x88, SP
10.go:12              0x4a991e                c3                      RET

10.go:12              0x4a991f                90                      NOPL
10.go:12              0x4a9920                e8bbc5fbff              CALL runtime.gcWriteBarrier(SB)
10.go:12              0x4a9925                e95bffffff              JMP 0x4a9885
; y != 0
10.go:14              0x4a992a                f20f10842490000000      MOVSD_XMM 0x90(SP), X0
10.go:14              0x4a9933                f20f5e842498000000      DIVSD 0x98(SP), X0
10.go:14              0x4a993c                f20f118424a0000000      MOVSD_XMM X0, 0xa0(SP)
10.go:14              0x4a9945                0f57c0                  XORPS X0, X0
10.go:14              0x4a9948                0f118424a8000000        MOVUPS X0, 0xa8(SP)
10.go:14              0x4a9950                488bac2480000000        MOVQ 0x80(SP), BP
10.go:14              0x4a9958                4881c488000000          ADDQ $0x88, SP
10.go:14              0x4a995f                90                      NOPL
10.go:14              0x4a9960                c3                      RET

10.go:10              0x4a9961                e83aa8fbff              CALL runtime.morestack_noctxt(SB)
10.go:10              0x4a9966                e955feffff              JMP main.Compute(SB)

扔到IDA反编译后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
__int64 *__usercall main_Compute@<rax>(__int64 a1, double a2)
{
  __int64 *result; // rax
  __int64 v3; // rax
  __int128 v4; // [rsp+58h] [rbp-30h] BYREF
  __int128 *v5; // [rsp+68h] [rbp-20h]
  __int64 v6; // [rsp+70h] [rbp-18h]
  __int64 v7; // [rsp+78h] [rbp-10h]
  __int64 v8; // [rsp+80h] [rbp-8h] BYREF

  while ( 1 )
  {
    result = &v8;
    if ( (unsigned __int64)&v8 > *(_QWORD *)(*(_QWORD *)NtCurrentTeb()->NtTib.ArbitraryUserPointer + 16LL) )
      break;
    runtime_morestack_noctxt();
  }
  if ( a2 == 0.0 )
  {
    v4 = 0LL;
    v3 = runtime_convT64(a1);
    *(_QWORD *)&v4 = &unk_4B4700;
    if ( runtime_writeBarrier )
      runtime_gcWriteBarrier();
    else
      *((_QWORD *)&v4 + 1) = v3;
    v5 = &v4;
    v6 = 1LL;
    v7 = 1LL;
    return (__int64 *)fmt_Errorf(&unk_4D288B, 23LL, &v4, 1LL, 1LL);
  }
  return result;
}

可以发现IDA居然把核心代码块给忽略掉了！所以说Go程序的伪代码不能完全相信。

测试错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
	"fmt"
)

func Callee(x int, y int) (int, error) {
	if y == 0 {
		return 0, fmt.Errorf("No 0")
	}
	return x / y, nil
}
func Caller() (int, error) {
	v, err := Callee(1, 0)
	if err != nil {
		return -1, err
	}
	return v + 1, nil
}

func main() {
	Caller()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
11.go:13              0x4a6ea0                65488b0c2528000000      MOVQ GS:0x28, CX
11.go:13              0x4a6ea9                488b8900000000          MOVQ 0(CX), CX
11.go:13              0x4a6eb0                483b6110                CMPQ 0x10(CX), SP
11.go:13              0x4a6eb4                0f86c9000000            JBE 0x4a6f83
11.go:13              0x4a6eba                4883ec60                SUBQ $0x60, SP
11.go:13              0x4a6ebe                48896c2458              MOVQ BP, 0x58(SP)
11.go:13              0x4a6ec3                488d6c2458              LEAQ 0x58(SP), BP

11.go:13              0x4a6ec8                48c744246800000000      MOVQ $0x0, 0x68(SP)
11.go:13              0x4a6ed1                0f57c0                  XORPS X0, X0
11.go:13              0x4a6ed4                0f11442470              MOVUPS X0, 0x70(SP)
11.go:14              0x4a6ed9                0f57c0                  XORPS X0, X0
11.go:14              0x4a6edc                0f11442448              MOVUPS X0, 0x48(SP)
; Callee(1, 0)
11.go:14              0x4a6ee1                48c7042401000000        MOVQ $0x1, 0(SP)
11.go:14              0x4a6ee9                48c744240800000000      MOVQ $0x0, 0x8(SP)
11.go:14              0x4a6ef2                e8a9feffff              CALL main.Callee(SB)
11.go:14              0x4a6ef7                488b442410              MOVQ 0x10(SP), AX
11.go:14              0x4a6efc                488b4c2418              MOVQ 0x18(SP), CX
11.go:14              0x4a6f01                488b542420              MOVQ 0x20(SP), DX
11.go:14              0x4a6f06                4889442430              MOVQ AX, 0x30(SP)
11.go:14              0x4a6f0b                48894c2448              MOVQ CX, 0x48(SP)
11.go:14              0x4a6f10                4889542450              MOVQ DX, 0x50(SP)
; 0x30 = int
; 0x48, 0x50 = error.vtable, error.value

; 0x28() = 0x30() = x int
11.go:14              0x4a6f15                488b442430              MOVQ 0x30(SP), AX
11.go:14              0x4a6f1a                4889442428              MOVQ AX, 0x28(SP)
; 0x38() = 0x48() = vtable
; 0x40() = 0x50() = value
11.go:14              0x4a6f1f                488b442448              MOVQ 0x48(SP), AX
11.go:14              0x4a6f24                488b4c2450              MOVQ 0x50(SP), CX
11.go:14              0x4a6f29                4889442438              MOVQ AX, 0x38(SP)
11.go:14              0x4a6f2e                48894c2440              MOVQ CX, 0x40(SP)
; err != nil?
11.go:15              0x4a6f33                48837c243800            CMPQ $0x0, 0x38(SP)
11.go:15              0x4a6f39                7502                    JNE 0x4a6f3d
11.go:15              0x4a6f3b                eb27                    JMP 0x4a6f64
; if err != nil
; 0x68() = -1
; 0x70(), 0x78() = err.vtable, err.value
11.go:16              0x4a6f3d                48c7442468ffffffff      MOVQ $-0x1, 0x68(SP)
11.go:16              0x4a6f46                488b442438              MOVQ 0x38(SP), AX
11.go:16              0x4a6f4b                488b4c2440              MOVQ 0x40(SP), CX
11.go:16              0x4a6f50                4889442470              MOVQ AX, 0x70(SP)
11.go:16              0x4a6f55                48894c2478              MOVQ CX, 0x78(SP)

11.go:16              0x4a6f5a                488b6c2458              MOVQ 0x58(SP), BP
11.go:16              0x4a6f5f                4883c460                ADDQ $0x60, SP
11.go:16              0x4a6f63                c3                      RET

; 0x68() = x + 1
; xmmword 0x70() = err
11.go:18              0x4a6f64                488b442428              MOVQ 0x28(SP), AX
11.go:18              0x4a6f69                48ffc0                  INCQ AX
11.go:18              0x4a6f6c                4889442468              MOVQ AX, 0x68(SP)
11.go:18              0x4a6f71                0f57c0                  XORPS X0, X0
11.go:18              0x4a6f74                0f11442470              MOVUPS X0, 0x70(SP)
11.go:18              0x4a6f79                488b6c2458              MOVQ 0x58(SP), BP
11.go:18              0x4a6f7e                4883c460                ADDQ $0x60, SP
11.go:18              0x4a6f82                c3                      RET
11.go:13              0x4a6f83                e898ccfbff              CALL runtime.morestack_noctxt(SB)
11.go:13              0x4a6f88                e913ffffff              JMP main.Caller(SB)

补充一下fmt.Errorf的源码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// src/fmt/errors.go

// Errorf formats according to a format specifier and returns the string as a
// value that satisfies error.
//
// If the format specifier includes a %w verb with an error operand,
// the returned error will implement an Unwrap method returning the operand. It is
// invalid to include more than one %w verb or to supply it with an operand
// that does not implement the error interface. The %w verb is otherwise
// a synonym for %v.
func Errorf(format string, a ...interface{}) error {
	p := newPrinter()
	p.wrapErrs = true
	p.doPrintf(format, a)
	s := string(p.buf)
	var err error
	if p.wrappedErr == nil {
		err = errors.New(s)
	} else {
		err = &wrapError{s, p.wrappedErr}
	}
	p.free()
	return err
}

其中第二个参数是个可变参数+空接口。后面再去分析这两个玩意。

defer的实现

defer简介：defer语句用于延迟函数的调用，每次 defer 都会把一个函数压入栈中，函数返回前再把延迟的函数取出并执行。Golang 中的 defer可以帮助我们处理容易忽略的问题，如资源释放、连接关闭等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (
	"fmt"
)

func f() {
	fmt.Println("514")
}
func Defer1() string {
	fmt.Println("114")
	defer f()
	fmt.Println(1919810)
	return "AAA"
}

func main() {
	fmt.Println(Defer1())
}

运行结果

1
2
3
4
114
1919810
514
AAA

可以发现defer确实将f()函数给推迟了。使得它在函数返回的时候才被调用，所以514是在1919810之后打印的。

汇编：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
TEXT main.Defer1(SB) C:/Users/任昊/Desktop/SSTudy/Go/Blog2/12.go
; 序言
  12.go:10              0x4a7b20                65488b0c2528000000              MOVQ GS:0x28, CX
  12.go:10              0x4a7b29                488b8900000000                  MOVQ 0(CX), CX
  12.go:10              0x4a7b30                488d4424a8                      LEAQ -0x58(SP), AX
  12.go:10              0x4a7b35                483b4110                        CMPQ 0x10(CX), AX
  12.go:10              0x4a7b39                0f868d010000                    JBE 0x4a7ccc
  12.go:10              0x4a7b3f                4881ecd8000000                  SUBQ $0xd8, SP
  12.go:10              0x4a7b46                4889ac24d0000000                MOVQ BP, 0xd0(SP)
  12.go:10              0x4a7b4e                488dac24d0000000                LEAQ 0xd0(SP), BP
  
  12.go:10              0x4a7b56                0f57c0                          XORPS X0, X0
  12.go:10              0x4a7b59                0f118424e0000000                MOVUPS X0, 0xe0(SP)
  12.go:11              0x4a7b61                0f57c0                          XORPS X0, X0
  12.go:11              0x4a7b64                0f11842490000000                MOVUPS X0, 0x90(SP)
  
  12.go:11              0x4a7b6c                488d842490000000                LEAQ 0x90(SP), AX
  12.go:11              0x4a7b74                4889842488000000                MOVQ AX, 0x88(SP)
  12.go:11              0x4a7b7c                8400                            TESTB AL, 0(AX)
  12.go:11              0x4a7b7e                488d0dfbb50000                  LEAQ type.*+45440(SB), CX
  12.go:11              0x4a7b85                48898c2490000000                MOVQ CX, 0x90(SP)
  12.go:11              0x4a7b8d                488d0d6c740400                  LEAQ sync/atomic.CompareAndSwapUintptr.args_stackmap+208(SB), CX
  12.go:11              0x4a7b94                48898c2498000000                MOVQ CX, 0x98(SP)
  12.go:11              0x4a7b9c                8400                            TESTB AL, 0(AX)
  12.go:11              0x4a7b9e                6690                            NOPW
  12.go:11              0x4a7ba0                eb00                            JMP 0x4a7ba2
  12.go:11              0x4a7ba2                48898424b8000000                MOVQ AX, 0xb8(SP)
  12.go:11              0x4a7baa                48c78424c000000001000000        MOVQ $0x1, 0xc0(SP)
  12.go:11              0x4a7bb6                48c78424c800000001000000        MOVQ $0x1, 0xc8(SP)
  12.go:11              0x4a7bc2                48890424                        MOVQ AX, 0(SP)
  12.go:11              0x4a7bc6                48c744240801000000              MOVQ $0x1, 0x8(SP)
  12.go:11              0x4a7bcf                48c744241001000000              MOVQ $0x1, 0x10(SP)
  12.go:11              0x4a7bd8                e86399ffff                      CALL fmt.Println(SB)
  ; fmt.Println("114")
  
  ; runtime.deferprocStack(*_defer), _defer.siz = 0; _defer.fn = go.func.*+178(f函数)
  12.go:12              0x4a7bdd                c744243000000000                MOVL $0x0, 0x30(SP) ; 030(SP) = 0
  12.go:12              0x4a7be5                488d0524e20200                  LEAQ go.func.*+178(SB), AX
  12.go:12              0x4a7bec                4889442448                      MOVQ AX, 0x48(SP) ; 0x48(SP) = gofunc
  12.go:12              0x4a7bf1                488d442430                      LEAQ 0x30(SP), AX ; AX = 0x30 + SP
  12.go:12              0x4a7bf6                48890424                        MOVQ AX, 0(SP)    ; arg0 = AX
  12.go:12              0x4a7bfa                e8c1c1f8ff                      CALL runtime.deferprocStack(SB)
  
  12.go:12              0x4a7bff                90                              NOPL
  12.go:12              0x4a7c00                85c0                            TESTL AX, AX
  12.go:12              0x4a7c02                0f85ae000000                    JNE 0x4a7cb6  ;有没有产生panic
  12.go:12              0x4a7c08                eb00                            JMP 0x4a7c0a
  
  12.go:13              0x4a7c0a                0f57c0                          XORPS X0, X0
  12.go:13              0x4a7c0d                0f11842490000000                MOVUPS X0, 0x90(SP)
  12.go:13              0x4a7c15                488d842490000000                LEAQ 0x90(SP), AX
  12.go:13              0x4a7c1d                4889842480000000                MOVQ AX, 0x80(SP)
  12.go:13              0x4a7c25                8400                            TESTB AL, 0(AX)
  12.go:13              0x4a7c27                488d0d52ae0000                  LEAQ type.*+43648(SB), CX
  12.go:13              0x4a7c2e                48898c2490000000                MOVQ CX, 0x90(SP)
  12.go:13              0x4a7c36                488d0d7b700400                  LEAQ $f64.bfe62e42fefa39ef+8(SB), CX
  12.go:13              0x4a7c3d                48898c2498000000                MOVQ CX, 0x98(SP)
  12.go:13              0x4a7c45                8400                            TESTB AL, 0(AX)
  12.go:13              0x4a7c47                eb00                            JMP 0x4a7c49
  12.go:13              0x4a7c49                48898424a0000000                MOVQ AX, 0xa0(SP)
  12.go:13              0x4a7c51                48c78424a800000001000000        MOVQ $0x1, 0xa8(SP)
  12.go:13              0x4a7c5d                48c78424b000000001000000        MOVQ $0x1, 0xb0(SP)
  12.go:13              0x4a7c69                48890424                        MOVQ AX, 0(SP)
  12.go:13              0x4a7c76                48c744241001000000              MOVQ $0x1, 0x10(SP)
  12.go:13              0x4a7c7f                90                              NOPL
  12.go:13              0x4a7c80                e8bb98ffff                      CALL fmt.Println(SB)
  ; fmt.Println("1919810")
  
  ; 在RET之前再调用deferreturn()；同时返回"AAA"字符串
  12.go:14              0x4a7c85                488d05f5490200                  LEAQ go.string.*+257(SB), AX; "AAA"
  12.go:14              0x4a7c8c                48898424e0000000                MOVQ AX, 0xe0(SP) 
  12.go:14              0x4a7c94                48c78424e800000003000000        MOVQ $0x3, 0xe8(SP)
  12.go:14              0x4a7ca0                90                              NOPL
  12.go:14              0x4a7ca1                e8fac9f8ff                      CALL runtime.deferreturn(SB)
  12.go:14              0x4a7ca6                488bac24d0000000                MOVQ 0xd0(SP), BP
  12.go:14              0x4a7cae                4881c4d8000000                  ADDQ $0xd8, SP
  12.go:14              0x4a7cb5                c3                              RET
  ; 有panic，但是deferreturn还是要触发。
  12.go:12              0x4a7cb6                90                              NOPL
  12.go:12              0x4a7cb7                e8e4c9f8ff                      CALL runtime.deferreturn(SB)
  12.go:12              0x4a7cbc                488bac24d0000000                MOVQ 0xd0(SP), BP
  12.go:12              0x4a7cc4                4881c4d8000000                  ADDQ $0xd8, SP
  12.go:12              0x4a7ccb                c3                              RET
  
  12.go:10              0x4a7ccc                e8cfc4fbff                      CALL runtime.morestack_noctxt(SB)
  12.go:10              0x4a7cd1                e94afeffff                      JMP main.Defer1(SB)

首先我们看到对runtime.deferprocStack()的调用。在go/src/runtime/panic.go中看源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// deferprocStack queues a new deferred function with a defer record on the stack.
// The defer record must have its siz and fn fields initialized.
// All other fields can contain junk.
// The defer record must be immediately followed in memory by
// the arguments of the defer.
// Nosplit because the arguments on the stack won't be scanned
// until the defer record is spliced into the gp._defer list.
//go:nosplit
func deferprocStack(d *_defer) {
	gp := getg()
	if gp.m.curg != gp {
		// go code on the system stack can't defer
		throw("defer on system stack")
	}
	// siz and fn are already set.
	// The other fields are junk on entry to deferprocStack and
	// are initialized here.
	d.started = false
	d.heap = false
	d.openDefer = false
	d.sp = getcallersp()
	d.pc = getcallerpc()
	d.framepc = 0
	d.varp = 0
	// The lines below implement:
	//   d.panic = nil
	//   d.fd = nil
	//   d.link = gp._defer
	//   gp._defer = d
	// But without write barriers. The first three are writes to
	// the stack so they don't need a write barrier, and furthermore
	// are to uninitialized memory, so they must not use a write barrier.
	// The fourth write does not require a write barrier because we
	// explicitly mark all the defer structures, so we don't need to
	// keep track of pointers to them with a write barrier.
	*(*uintptr)(unsafe.Pointer(&d._panic)) = 0
	*(*uintptr)(unsafe.Pointer(&d.fd)) = 0
	*(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))
	*(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))

	return0()
	// No code can go here - the C return register has
	// been set and must not be clobbered.
}

anyway，大概的意思就是在栈上创建了一个defer record。然后根据函数原型，我们再查查结构体_defer是个啥。

在runtime/runtime2.go中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
type _defer struct {
    // 4
	siz     int32 // includes both arguments and results
    // 1
	started bool
    // 1
	heap    bool
	// openDefer indicates that this _defer is for a frame with open-coded
	// defers. We have only one defer record for the entire frame (which may
	// currently have 0, 1, or more defers active).
    // 1
	openDefer bool
    // 没对齐，可能有1字节padding？
    // 8
	sp        uintptr  // sp at time of defer
    // 8
	pc        uintptr  // pc at time of defer
    // 8
	fn        *funcval // can be nil for open-coded defers       +0x18
    // 8
	_panic    *_panic  // panic that is running defer
    // 8
	link      *_defer

	// If openDefer is true, the fields below record values about the stack
	// frame and associated function that has the open-coded defer(s). sp
	// above will be the sp for the frame, and pc will be address of the
	// deferreturn call in the function.
    // 8
	fd   unsafe.Pointer // funcdata for the function associated with the frame
    // 8
	varp uintptr        // value of varp for the stack frame
	// framepc is the current pc associated with the stack frame. Together,
	// with sp above (which is the sp associated with the stack frame),
	// framepc/sp can be used as pc/sp pair to continue a stack trace via
	// gentraceback().
    // 8
	framepc uintptr
}

不过由于传入的是个指针，所以只需要一个QWORD传入函数里。但是由于_defer结构体中的第一个成员siz和偏移0x18成员fn都需要初始化，所以可以看到：

1
2
3
4
5
6
7
; runtime.deferprocStack(*_defer), _defer.siz = 0; _defer.fn = go.func.*+178(f函数)
12.go:12              0x4a7bdd                c744243000000000                MOVL $0x0, 0x30(SP) ; 030(SP) = 0
12.go:12              0x4a7be5                488d0524e20200                  LEAQ go.func.*+178(SB), AX
12.go:12              0x4a7bec                4889442448                      MOVQ AX, 0x48(SP) ; 0x48(SP) = gofunc
12.go:12              0x4a7bf1                488d442430                      LEAQ 0x30(SP), AX ; AX = 0x30 + SP
12.go:12              0x4a7bf6                48890424                        MOVQ AX, 0(SP)    ; arg0 = AX
12.go:12              0x4a7bfa                e8c1c1f8ff                      CALL runtime.deferprocStack(SB)

从0x30到0x48正好偏移0x18，可以推测前面这几行就是初始化结构体，且结构体在栈上。（对应了函数的介绍，defer record on the stack）

然后立刻进行TEST，看有没有产生panic。

最后在RET前调用deferreturn()触发预置函数。

defer闭包

一般情况下我们都会用闭包函数触发defer。

1
2
3
4
5
6
func Defer2() (res int) { // 返回值res
    defer func() {
            res = 123
    }()
    return -1
}

这个程序最终将返回123而非-1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
TEXT main.Defer2(SB) 
  13.go:3               0x462800                65488b0c2528000000      MOVQ GS:0x28, CX
  13.go:3               0x462809                488b8900000000          MOVQ 0(CX), CX
  13.go:3               0x462810                483b6110                CMPQ 0x10(CX), SP
  13.go:3               0x462814                7672                    JBE 0x462888
  13.go:3               0x462816                4883ec60                SUBQ $0x60, SP
  13.go:3               0x46281a                48896c2458              MOVQ BP, 0x58(SP)
  13.go:3               0x46281f                488d6c2458              LEAQ 0x58(SP), BP
  
  13.go:3               0x462824                48c744246800000000      MOVQ $0x0, 0x68(SP)
  13.go:4               0x46282d                c744240808000000        MOVL $0x8, 0x8(SP) ; 0x8(SP) = 8
  13.go:4               0x462835                488d05fcad0100          LEAQ go.func.*+72(SB), AX
  13.go:4               0x46283c                4889442420              MOVQ AX, 0x20(SP)  ; 0x20(SP) = func1
  13.go:4               0x462841                488d442468              LEAQ 0x68(SP), AX
  13.go:4               0x462846                4889442450              MOVQ AX, 0x50(SP)  ; 0x50(SP) = 0x68+SP
  13.go:4               0x46284b                488d442408              LEAQ 0x8(SP), AX   ; AX = 0x8+SP
  13.go:4               0x462850                48890424                MOVQ AX, 0(SP) ;指向_defer结构体的指针  
  13.go:4               0x462854                e8e7c3fcff              CALL runtime.deferprocStack(SB)
  ; deferprocStack(*_defer), _defer.siz=8, _defer.fn=&func1
  
  13.go:4               0x462859                85c0                    TESTL AX, AX
  13.go:4               0x46285b                751b                    JNE 0x462878   ; panic?
  13.go:4               0x46285d                eb00                    JMP 0x46285f
  ; retval = -1
  13.go:7               0x46285f                48c7442468ffffffff      MOVQ $-0x1, 0x68(SP)
  13.go:7               0x462868                90                      NOPL
  ; call func1()
  13.go:7               0x462869                e8b2ccfcff              CALL runtime.deferreturn(SB)
  13.go:7               0x46286e                488b6c2458              MOVQ 0x58(SP), BP
  13.go:7               0x462873                4883c460                ADDQ $0x60, SP
  13.go:7               0x462877                c3                      RET
  13.go:4               0x462878                90                      NOPL
  13.go:4               0x462879                e8a2ccfcff              CALL runtime.deferreturn(SB)
  13.go:4               0x46287e                488b6c2458              MOVQ 0x58(SP), BP
  13.go:4               0x462883                4883c460                ADDQ $0x60, SP
  13.go:4               0x462887                c3                      RET
  
  ; panic
  13.go:3               0x462888                e83387ffff              CALL runtime.morestack_noctxt(SB)
  13.go:3               0x46288d                e96effffff              JMP main.Defer2(SB)
  :-1                   0x462892                cc                      INT $0x3
  :-1                   0x462893                cc                      INT $0x3
  :-1                   0x462894                cc                      INT $0x3
  :-1                   0x462895                cc                      INT $0x3
  :-1                   0x462896                cc                      INT $0x3
  :-1                   0x462897                cc                      INT $0x3
  :-1                   0x462898                cc                      INT $0x3
  :-1                   0x462899                cc                      INT $0x3
  :-1                   0x46289a                cc                      INT $0x3
  :-1                   0x46289b                cc                      INT $0x3
  :-1                   0x46289c                cc                      INT $0x3
  :-1                   0x46289d                cc                      INT $0x3
  :-1                   0x46289e                cc                      INT $0x3
  :-1                   0x46289f                cc                      INT $0x3

TEXT main.Defer2.func1(SB)
  ; 第一个参数是指向上级函数的栈帧指针
  13.go:5               0x4628e0                488b442408              MOVQ 0x8(SP), AX
  ; 123设定为上级函数的返回值
  13.go:5               0x4628e5                48c7007b000000          MOVQ $0x7b, 0(AX)
  13.go:6               0x4628ec                c3                      RET
  :0                    0x4628ed                cc                      INT $0x3
  :0                    0x4628ee                cc                      INT $0x3
  :0                    0x4628ef                cc                      INT $0x3

总结一下：编译后闭包函数会变成一个匿名函数，此匿名函数有一个默认传入参数，即上级函数的栈帧指针。通过取得它便可修改上级函数里面的变量值，实现对返回值的修改。

panic的实现

在函数中使用panic()

panic就是错误抛出

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

func Panic1() { panic(nil) }

var x int

func Panic2() { panic(&x) }

func main() {
	Panic1()
	Panic2()
}

得到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
TEXT main.Panic1(SB)
  14.go:3               0x462720                65488b0c2528000000      MOVQ GS:0x28, CX
  14.go:3               0x462729                488b8900000000          MOVQ 0(CX), CX
  14.go:3               0x462730                483b6110                CMPQ 0x10(CX), SP
  14.go:3               0x462734                761b                    JBE 0x462751
  14.go:3               0x462736                4883ec18                SUBQ $0x18, SP
  14.go:3               0x46273a                48896c2410              MOVQ BP, 0x10(SP)
  14.go:3               0x46273f                488d6c2410              LEAQ 0x10(SP), BP
  
  ; runtime.gopanic(xmmword 0)
  14.go:3               0x462744                0f57c0                  XORPS X0, X0
  14.go:3               0x462747                0f110424                MOVUPS X0, 0(SP)
  14.go:3               0x46274b                e8d0dcfcff              CALL runtime.gopanic(SB)
  
  14.go:3               0x462750                90                      NOPL
  14.go:3               0x462751                e8aa87ffff              CALL runtime.morestack_noctxt(SB)
  14.go:3               0x462756                ebc8                    JMP main.Panic1(SB)

TEXT main.Panic2(SB)
  14.go:7               0x462760                65488b0c2528000000      MOVQ GS:0x28, CX
  14.go:7               0x462769                488b8900000000          MOVQ 0(CX), CX
  14.go:7               0x462770                483b6110                CMPQ 0x10(CX), SP
  14.go:7               0x462774                7630                    JBE 0x4627a6
  14.go:7               0x462776                4883ec20                SUBQ $0x20, SP
  14.go:7               0x46277a                48896c2418              MOVQ BP, 0x18(SP)
  14.go:7               0x46277f                488d6c2418              LEAQ 0x18(SP), BP
  14.go:7               0x462784                488d05fdf20a00          LEAQ main.x(SB), AX
  14.go:7               0x46278b                4889442410              MOVQ AX, 0x10(SP)
  14.go:7               0x462790                488d0d294c0000          LEAQ type.*+17344(SB), CX
  14.go:7               0x462797                48890c24                MOVQ CX, 0(SP)
  14.go:7               0x46279b                4889442408              MOVQ AX, 0x8(SP)
  ; gopanic(QWORD &type_vtable, QWORD &x)
  14.go:7               0x4627a0                e87bdcfcff              CALL runtime.gopanic(SB)
  
  14.go:7               0x4627a5                90                      NOPL
  14.go:7               0x4627a6                e85587ffff              CALL runtime.morestack_noctxt(SB)
  14.go:7               0x4627ab                ebb3                    JMP main.Panic2(SB)

日常源码：

1
2
// runtime/panic.go/gopanic
func gopanic(e interface{}) {/*太长了故略*/}

传入任意一种接口，所以在传入的参数会在编译时转化成接口类型后再调用。

Panic1()

interface{nil}会被优化成传入1个XMMWORD的0

Panic2()

interface{x}中的第一个QWORD传入的是一个默认类型作为vtable，第二个就是x变量的指针指向其value。

捕捉异常：defer+recover

Go中没有try-catch异常捕获机制，但是提供了recover()伪函数来实现这一过程。

当程序员想要捕获foo()或其调用的函数中的异常时，需要

  1. 一个单独的函数或者闭包函数（反正不能是foo自己），且包含一个recover()调用
  2. 必须从foo()函数用defer来调用这个独立的函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func Recovering(r *int) {
    // The pseudo-function recover() returns nil by default, except when
    // called in a deferred activation, in which case it catches the
    // exception object, stops stack unwinding and returns the exception
    // object as its return value.
    if recover() != nil {
       *r = 123
    }
}

func TryCatch() (res int) {
    defer Recovering(&res)
    // call a function that may throw an exception.
    f()
    // Regular path: return -1
    res = -1
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
TEXT main.Recovering(SB)
  15.go:12              0x4a7b00                65488b0c2528000000      MOVQ GS:0x28, CX
  15.go:12              0x4a7b09                488b8900000000          MOVQ 0(CX), CX
  15.go:12              0x4a7b10                483b6110                CMPQ 0x10(CX), SP
  15.go:12              0x4a7b14                7658                    JBE 0x4a7b6e
  15.go:12              0x4a7b16                4883ec30                SUBQ $0x30, SP
  15.go:12              0x4a7b1a                48896c2428              MOVQ BP, 0x28(SP)
  15.go:12              0x4a7b1f                488d6c2428              LEAQ 0x28(SP), BP
  
  ; AX, CX = gorecover(0x38+SP)
  15.go:17              0x4a7b24                488d442438              LEAQ 0x38(SP), AX
  15.go:17              0x4a7b29                48890424                MOVQ AX, 0(SP)
  15.go:17              0x4a7b2d                e8cee3f8ff              CALL runtime.gorecover(SB)
  15.go:17              0x4a7b32                488b442408              MOVQ 0x8(SP), AX
  15.go:17              0x4a7b37                488b4c2410              MOVQ 0x10(SP), CX
  ; recover() == nil:
  15.go:17              0x4a7b3c                48837c240800            CMPQ $0x0, 0x8(SP)
  15.go:17              0x4a7b42                4889442418              MOVQ AX, 0x18(SP)
  15.go:17              0x4a7b47                48894c2420              MOVQ CX, 0x20(SP)
  15.go:17              0x4a7b4c                7502                    JNE 0x4a7b50
  15.go:17              0x4a7b4e                eb1c                    JMP 0x4a7b6c
  
  15.go:18              0x4a7b50                488b442438              MOVQ 0x38(SP), AX
  15.go:18              0x4a7b55                8400                    TESTB AL, 0(AX)
  ; *r = 123
  15.go:18              0x4a7b57                48c7007b000000          MOVQ $0x7b, 0(AX)
  15.go:18              0x4a7b5e                6690                    NOPW
  15.go:18              0x4a7b60                eb00                    JMP 0x4a7b62
  15.go:18              0x4a7b62                488b6c2428              MOVQ 0x28(SP), BP
  15.go:18              0x4a7b67                4883c430                ADDQ $0x30, SP
  15.go:18              0x4a7b6b                c3                      RET
  
  15.go:17              0x4a7b6c                ebf4                    JMP 0x4a7b62
  15.go:12              0x4a7b6e                e82dc6fbff              CALL runtime.morestack_noctxt(SB)
  15.go:12              0x4a7b73                eb8b                    JMP main.Recovering(SB)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func gorecover(argp uintptr) interface{} {
	// Must be in a function running as part of a deferred call during the panic.
	// Must be called from the topmost function of the call
	// (the function used in the defer statement).
	// p.argp is the argument pointer of that topmost deferred function call.
	// Compare against argp reported by caller.
	// If they match, the caller is the one who can recover.
	gp := getg() // get goroutine; g结构体
	p := gp._panic
	if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
		p.recovered = true
		return p.arg
	}
	return nil
}

返回了个g._panic.arg且转换成了interface{}类型，所以有2QWORD。这个函数大概就是获取goroutine结构体g，然后查看有没有发现正在进行的异常，然后相应的返回特定值。没有异常就返回nil。

gccgo

全新的编译器实现，又是一个很大的类。不过我不打算仔细研究。稍微了解即可。

即使用gcc编译器对Go语言进行编译，其支持的优化相比传统默认Go编译器有着比较大的改进。

https://go.dev/doc/install/gccgo

里面有安装编译教程。

我直接在Ubuntu上面

1
sudo apt install gccgo

即可获取最新版本gccgo。

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func EmptyFunc()              {}                   // 无参无返回
func FuncConst() int          { return 123 }       // 无参返回常量
func FuncAdd(x, y, z int) int { return x + y - z } // 3int返回1int

func main() {
	fmt.Println("AAA")
	fmt.Println(FuncConst())
	fmt.Println(FuncAdd(1, 2, 3))
}

和一般的gcc没啥区别。

1
gccgo 1.go -o 1_gcc
1
2
3
4
./1_gcc
AAA
123
0

看一下IDA。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
void __cdecl main_main()
{
  __int64 v0; // rax
  __int64 v1; // rbx
  __int64 v2; // rax
  __int64 v3; // rbx
  _QWORD v4[4]; // [rsp+0h] [rbp-188h] BYREF
  _QWORD v5[5]; // [rsp+20h] [rbp-168h] BYREF
  _QWORD *v6; // [rsp+48h] [rbp-140h]
  _QWORD v7[5]; // [rsp+50h] [rbp-138h] BYREF
  _QWORD *v8; // [rsp+78h] [rbp-110h]
  _QWORD v9[33]; // [rsp+80h] [rbp-108h] BYREF

  if ( (unsigned __int64)v4 >= __readfsqword(0x70u) )
  {
    v5[0] = &string__d;
    v5[1] = &go__C6;
    v9[2] = v5;
    v9[3] = 1LL;
    v9[4] = 1LL;
    fmt_Println(v5, 1LL, 1LL);
    v4[0] = v9[6];
    v4[1] = v9[7];
    v4[2] = v9[8];
    main_FuncConst();
    v1 = v0;
    v6 = (_QWORD *)runtime_newobject();
    *v6 = v1;
    v7[0] = &int__d;
    v7[1] = v6;
    v9[10] = v7;
    v9[11] = 1LL;
    v9[12] = 1LL;
    fmt_Println(v7, 1LL, 1LL);
    v5[2] = v9[14];
    v5[3] = v9[15];
    v5[4] = v9[16];
    main_FuncAdd();
    v3 = v2;
    v8 = (_QWORD *)runtime_newobject();
    *v8 = v3;
    v9[0] = &int__d;
    v9[1] = v8;
    v9[18] = v9;
    v9[19] = 1LL;
    v9[20] = 1LL;
    fmt_Println(v9, 1LL, 1LL);
  }
  else
  {
    _morestack();
  }
}

Go的分析也很依赖汇编，所以看一下汇编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
.text:00000000000033B0 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:00000000000033B0                 public main
.text:00000000000033B0 main            proc near               ; DATA XREF: _start+21↓o
.text:00000000000033B0
.text:00000000000033B0 var_14          = dword ptr -14h
.text:00000000000033B0 var_10          = qword ptr -10h
.text:00000000000033B0
.text:00000000000033B0 argc = rdi                              ; int
.text:00000000000033B0 argv = rsi                              ; char **
.text:00000000000033B0 ; __unwind {
.text:00000000000033B0                 endbr64
.text:00000000000033B4                 cmp     rsp, fs:70h
.text:00000000000033BD                 jb      short loc_33D8
.text:00000000000033BF
.text:00000000000033BF loc_33BF:                               ; CODE XREF: main+3B↓j
.text:00000000000033BF                 mov     rax, cs:runtime_isarchive_ptr
.text:00000000000033C6                 mov     byte ptr [rax], 0
.text:00000000000033C9                 mov     rax, cs:runtime_isstarted_ptr
.text:00000000000033D0                 cmp     byte ptr [rax], 0
.text:00000000000033D3                 jz      short loc_33ED
.text:00000000000033D5                 xor     eax, eax
.text:00000000000033D7                 retn
.text:00000000000033D8 ; ---------------------------------------------------------------------------
.text:00000000000033D8
.text:00000000000033D8 loc_33D8:                               ; CODE XREF: main+D↑j
.text:00000000000033D8 argc = rdi                              ; int
.text:00000000000033D8 argv = rsi                              ; char **
.text:00000000000033D8                 mov     r10d, 18h
.text:00000000000033DE                 xor     r11d, r11d
.text:00000000000033E1                 call    __morestack
.text:00000000000033E6                 retn
.text:00000000000033E7 ; ---------------------------------------------------------------------------
.text:00000000000033E7                 endbr64
.text:00000000000033EB                 jmp     short loc_33BF
.text:00000000000033ED ; ---------------------------------------------------------------------------
.text:00000000000033ED
.text:00000000000033ED loc_33ED:                               ; CODE XREF: main+23↑j
.text:00000000000033ED                 sub     rsp, 18h
.text:00000000000033F1                 mov     byte ptr [rax], 1
.text:00000000000033F4                 mov     rax, cs:runtime_iscgo_ptr
.text:00000000000033FB                 cmp     byte ptr [rax], 0
.text:00000000000033FE                 jnz     short loc_3461
.text:0000000000003400
.text:0000000000003400 loc_3400:                               ; CODE XREF: main+C8↓j
.text:0000000000003400                 lea     rdx, _end
.text:0000000000003407                 lea     rax, __go_end
.text:000000000000340E                 mov     [rsp+18h+var_10], rsi
.text:0000000000003413                 mov     [rsp+18h+var_14], edi
.text:0000000000003417                 mov     [rax], rdx
.text:000000000000341A                 call    _runtime_ginit
.text:000000000000341F                 call    _runtime_cpuinit
.text:0000000000003424                 call    _runtime_check
.text:0000000000003429                 mov     rsi, [rsp+18h+var_10]
.text:000000000000342E                 mov     edi, [rsp+18h+var_14]
.text:0000000000003432                 call    _runtime_args
.text:0000000000003437                 call    _runtime_osinit
.text:000000000000343C                 call    _runtime_schedinit
.text:0000000000003441                 mov     rdi, cs:runtime_main_ptr
.text:0000000000003448                 xor     esi, esi
.text:000000000000344A                 call    ___go_go
.text:000000000000344F                 call    _runtime_m
.text:0000000000003454                 mov     rdi, rax
.text:0000000000003457                 call    _runtime_mstart
.text:000000000000345C                 call    _abort
.text:0000000000003461 ; ---------------------------------------------------------------------------
.text:0000000000003461
.text:0000000000003461 loc_3461:                               ; CODE XREF: main+4E↑j
.text:0000000000003461                 mov     [rsp+18h+var_10], rsi
.text:0000000000003466                 mov     [rsp+18h+var_14], edi
.text:000000000000346A                 call    _runtime_setIsCgo
.text:000000000000346F                 mov     rsi, [rsp+18h+var_10]
.text:0000000000003474                 mov     edi, [rsp+18h+var_14]
.text:0000000000003478                 jmp     short loc_3400
.text:0000000000003478 ; } // starts at 33B0
.text:0000000000003478 main            endp
.text:0000000000003478
.text:0000000000003478 ; ---------------------------------------------------------------------------
.text:000000000000347A                 align 20h
.text:0000000000003480
.text:0000000000003480 ; =============== S U B R O U T I N E =======================================
.text:0000000000003480
.text:0000000000003480 ; Attributes: noreturn fuzzy-sp
.text:0000000000003480
.text:0000000000003480                 public _start
.text:0000000000003480 _start          proc near               ; DATA XREF: LOAD:0000000000000018↑o
.text:0000000000003480 ; __unwind {
.text:0000000000003480                 endbr64
.text:0000000000003484                 xor     ebp, ebp
.text:0000000000003486                 mov     r9, rdx
.text:0000000000003489                 pop     rsi
.text:000000000000348A                 mov     rdx, rsp
.text:000000000000348D                 and     rsp, 0FFFFFFFFFFFFFFF0h
.text:0000000000003491                 push    rax             ; argc
.text:0000000000003492                 push    rsp             ; main
.text:0000000000003493                 lea     r8, __libc_csu_fini
.text:000000000000349A                 lea     rcx, __libc_csu_init
.text:00000000000034A1                 lea     rdi, main
.text:00000000000034A8                 call    cs:__libc_start_main_ptr
.text:00000000000034AE                 hlt
.text:00000000000034AE ; } // starts at 3480
.text:00000000000034AE _start          endp
.text:00000000000034AE
.text:00000000000034AE ; ---------------------------------------------------------------------------
.text:00000000000034AF                 align 10h
.text:00000000000034B0
.text:00000000000034B0 ; =============== S U B R O U T I N E =======================================
.text:00000000000034B0
.text:00000000000034B0
.text:00000000000034B0 deregister_tm_clones proc near          ; CODE XREF: __do_global_dtors_aux:loc_3547↓p
.text:00000000000034B0                 lea     rdi, _edata
.text:00000000000034B7                 lea     rax, _edata
.text:00000000000034BE                 cmp     rax, rdi
.text:00000000000034C1                 jz      short locret_34D8
.text:00000000000034C3                 mov     rax, cs:_ITM_deregisterTMCloneTable_ptr
.text:00000000000034CA                 test    rax, rax
.text:00000000000034CD                 jz      short locret_34D8
.text:00000000000034CF                 jmp     rax
.text:00000000000034CF ; ---------------------------------------------------------------------------
.text:00000000000034D1                 align 8
.text:00000000000034D8
.text:00000000000034D8 locret_34D8:                            ; CODE XREF: deregister_tm_clones+11↑j
.text:00000000000034D8                                         ; deregister_tm_clones+1D↑j
.text:00000000000034D8                 retn
.text:00000000000034D8 deregister_tm_clones endp
.text:00000000000034D8
.text:00000000000034D8 ; ---------------------------------------------------------------------------
.text:00000000000034D9                 align 20h
.text:00000000000034E0
.text:00000000000034E0 ; =============== S U B R O U T I N E =======================================
.text:00000000000034E0
.text:00000000000034E0
.text:00000000000034E0 register_tm_clones proc near            ; CODE XREF: frame_dummy+4↓j
.text:00000000000034E0                 lea     rdi, _edata
.text:00000000000034E7                 lea     rsi, _edata
.text:00000000000034EE                 sub     rsi, rdi
.text:00000000000034F1                 mov     rax, rsi
.text:00000000000034F4                 shr     rsi, 3Fh
.text:00000000000034F8                 sar     rax, 3
.text:00000000000034FC                 add     rsi, rax
.text:00000000000034FF                 sar     rsi, 1
.text:0000000000003502                 jz      short locret_3518
.text:0000000000003504                 mov     rax, cs:_ITM_registerTMCloneTable_ptr
.text:000000000000350B                 test    rax, rax
.text:000000000000350E                 jz      short locret_3518
.text:0000000000003510                 jmp     rax
.text:0000000000003510 ; ---------------------------------------------------------------------------
.text:0000000000003512                 align 8
.text:0000000000003518
.text:0000000000003518 locret_3518:                            ; CODE XREF: register_tm_clones+22↑j
.text:0000000000003518                                         ; register_tm_clones+2E↑j
.text:0000000000003518                 retn
.text:0000000000003518 register_tm_clones endp
.text:0000000000003518
.text:0000000000003518 ; ---------------------------------------------------------------------------
.text:0000000000003519                 align 20h
.text:0000000000003520
.text:0000000000003520 ; =============== S U B R O U T I N E =======================================
.text:0000000000003520
.text:0000000000003520
.text:0000000000003520 __do_global_dtors_aux proc near         ; DATA XREF: .fini_array:__do_global_dtors_aux_fini_array_entry↓o
.text:0000000000003520                 endbr64
.text:0000000000003524                 cmp     cs:completed_0, 0
.text:000000000000352B                 jnz     short locret_3558
.text:000000000000352D                 push    rbp             ; void *
.text:000000000000352E                 cmp     cs:__cxa_finalize_ptr, 0
.text:0000000000003536                 mov     rbp, rsp
.text:0000000000003539                 jz      short loc_3547
.text:000000000000353B                 mov     rdi, cs:__dso_handle
.text:0000000000003542                 call    __cxa_finalize
.text:0000000000003547
.text:0000000000003547 loc_3547:                               ; CODE XREF: __do_global_dtors_aux+19↑j
.text:0000000000003547                 call    deregister_tm_clones
.text:000000000000354C                 mov     cs:completed_0, 1
.text:0000000000003553                 pop     rbp
.text:0000000000003554                 retn
.text:0000000000003554 ; ---------------------------------------------------------------------------
.text:0000000000003555                 align 8
.text:0000000000003558
.text:0000000000003558 locret_3558:                            ; CODE XREF: __do_global_dtors_aux+B↑j
.text:0000000000003558                 retn
.text:0000000000003558 __do_global_dtors_aux endp
.text:0000000000003558
.text:0000000000003558 ; ---------------------------------------------------------------------------
.text:0000000000003559                 align 20h
.text:0000000000003560
.text:0000000000003560 ; =============== S U B R O U T I N E =======================================
.text:0000000000003560
.text:0000000000003560
.text:0000000000003560 frame_dummy     proc near               ; CODE XREF: __libc_csu_init+49↓p
.text:0000000000003560                                         ; DATA XREF: .init_array:__frame_dummy_init_array_entry↓o
.text:0000000000003560                 endbr64
.text:0000000000003564                 jmp     register_tm_clones
.text:0000000000003564 frame_dummy     endp
.text:0000000000003564
.text:0000000000003569
.text:0000000000003569 ; =============== S U B R O U T I N E =======================================
.text:0000000000003569
.text:0000000000003569 ; Attributes: bp-based frame
.text:0000000000003569
.text:0000000000003569 ; void __golang main_EmptyFunc()
.text:0000000000003569                 public main_EmptyFunc
.text:0000000000003569 main_EmptyFunc  proc near               ; DATA XREF: .data.rel.ro:main_EmptyFunc__f↓o
.text:0000000000003569 ; __unwind {
.text:0000000000003569                 cmp     rsp, fs:70h
.text:0000000000003572                 jnb     short loc_3586
.text:0000000000003574                 mov     r10d, 8
.text:000000000000357A                 mov     r11d, 0
.text:0000000000003580                 call    __morestack
.text:0000000000003585                 retn
.text:0000000000003586 ; ---------------------------------------------------------------------------
.text:0000000000003586
.text:0000000000003586 loc_3586:                               ; CODE XREF: main_EmptyFunc+9↑j
.text:0000000000003586                 push    rbp
.text:0000000000003587                 mov     rbp, rsp
.text:000000000000358A                 pop     rbp
.text:000000000000358B                 retn
.text:000000000000358B ; } // starts at 3569
.text:000000000000358B main_EmptyFunc  endp
.text:000000000000358B
.text:000000000000358C
.text:000000000000358C ; =============== S U B R O U T I N E =======================================
.text:000000000000358C
.text:000000000000358C ; Attributes: bp-based frame
.text:000000000000358C
.text:000000000000358C ; void __golang main_FuncConst()
.text:000000000000358C                 public main_FuncConst
.text:000000000000358C main_FuncConst  proc near               ; CODE XREF: main_main+CC↓p
.text:000000000000358C                                         ; DATA XREF: .data.rel.ro:main_FuncConst__f↓o
.text:000000000000358C
.text:000000000000358C var_8           = qword ptr -8
.text:000000000000358C
.text:000000000000358C ; __unwind {
.text:000000000000358C                 cmp     rsp, fs:70h
.text:0000000000003595                 jnb     short loc_35A9
.text:0000000000003597                 mov     r10d, 8
.text:000000000000359D                 mov     r11d, 0
.text:00000000000035A3                 call    __morestack
.text:00000000000035A8                 retn
.text:00000000000035A9 ; ---------------------------------------------------------------------------
.text:00000000000035A9
.text:00000000000035A9 loc_35A9:                               ; CODE XREF: main_FuncConst+9↑j
.text:00000000000035A9                 push    rbp
.text:00000000000035AA                 mov     rbp, rsp
.text:00000000000035AD                 mov     [rbp+var_8], 0
.text:00000000000035B5                 mov     [rbp+var_8], 7Bh ; '{'
.text:00000000000035BD                 mov     rax, [rbp+var_8]
.text:00000000000035C1                 pop     rbp
.text:00000000000035C2                 retn
.text:00000000000035C2 ; } // starts at 358C
.text:00000000000035C2 main_FuncConst  endp
.text:00000000000035C2
.text:00000000000035C3
.text:00000000000035C3 ; =============== S U B R O U T I N E =======================================
.text:00000000000035C3
.text:00000000000035C3 ; Attributes: bp-based frame
.text:00000000000035C3
.text:00000000000035C3 ; void __golang main_FuncAdd()
.text:00000000000035C3                 public main_FuncAdd
.text:00000000000035C3 main_FuncAdd    proc near               ; CODE XREF: main_main+193↓p
.text:00000000000035C3                                         ; DATA XREF: .data.rel.ro:main_FuncAdd__f↓o
.text:00000000000035C3
.text:00000000000035C3 var_28          = qword ptr -28h
.text:00000000000035C3 var_20          = qword ptr -20h
.text:00000000000035C3 var_18          = qword ptr -18h
.text:00000000000035C3 var_8           = qword ptr -8
.text:00000000000035C3
.text:00000000000035C3 ; __unwind {
.text:00000000000035C3                 cmp     rsp, fs:70h
.text:00000000000035CC                 jnb     short loc_35E0
.text:00000000000035CE                 mov     r10d, 8
.text:00000000000035D4                 mov     r11d, 0
.text:00000000000035DA                 call    __morestack
.text:00000000000035DF                 retn
.text:00000000000035E0 ; ---------------------------------------------------------------------------
.text:00000000000035E0
.text:00000000000035E0 loc_35E0:                               ; CODE XREF: main_FuncAdd+9↑j
.text:00000000000035E0                 push    rbp
.text:00000000000035E1                 mov     rbp, rsp
.text:00000000000035E4                 mov     [rbp+var_18], rdi
.text:00000000000035E8                 mov     [rbp+var_20], rsi
.text:00000000000035EC                 mov     [rbp+var_28], rdx
.text:00000000000035F0                 mov     [rbp+var_8], 0
.text:00000000000035F8                 mov     rdx, [rbp+var_18]
.text:00000000000035FC                 mov     rax, [rbp+var_20]
.text:0000000000003600                 add     rax, rdx
.text:0000000000003603                 sub     rax, [rbp+var_28]
.text:0000000000003607                 mov     [rbp+var_8], rax
.text:000000000000360B                 mov     rax, [rbp+var_8]
.text:000000000000360F                 pop     rbp
.text:0000000000003610                 retn
.text:0000000000003610 ; } // starts at 35C3
.text:0000000000003610 main_FuncAdd    endp
.text:0000000000003610
.text:0000000000003611
.text:0000000000003611 ; =============== S U B R O U T I N E =======================================
.text:0000000000003611
.text:0000000000003611
.text:0000000000003611 ; void __cdecl main_main()
.text:0000000000003611                 public main_main
.text:0000000000003611 main_main       proc near               ; DATA XREF: LOAD:0000000000000DC8↑o
.text:0000000000003611
.text:0000000000003611 var_188         = qword ptr -188h
.text:0000000000003611 anonymous_0     = qword ptr -140h
.text:0000000000003611 anonymous_1     = qword ptr -110h
.text:0000000000003611
.text:0000000000003611 ; __unwind {
.text:0000000000003611                 lea     r11, [rsp+var_188]
.text:0000000000003619                 cmp     r11, fs:70h
.text:0000000000003622                 jnb     short loc_3636
.text:0000000000003624                 mov     r10d, 188h
.text:000000000000362A                 mov     r11d, 0
.text:0000000000003630                 call    __morestack
.text:0000000000003635                 retn
.text:0000000000003636 ; ---------------------------------------------------------------------------
.text:0000000000003636
.text:0000000000003636 loc_3636:                               ; CODE XREF: main_main+11↑j
.text:0000000000003636                 push    rbp
.text:0000000000003637                 mov     rbp, rsp
.text:000000000000363A                 push    r15
.text:000000000000363C                 push    r14
.text:000000000000363E                 push    r13
.text:0000000000003640                 push    r12
.text:0000000000003642                 push    rbx
.text:0000000000003643                 sub     rsp, 158h
.text:000000000000364A                 lea     rax, string__d
.text:0000000000003651                 lea     rdx, go__C6
.text:0000000000003658                 mov     [rbp-160h], rax
.text:000000000000365F                 mov     [rbp-158h], rdx
.text:0000000000003666                 lea     rax, [rbp-160h]
.text:000000000000366D                 mov     [rbp-0F0h], rax
.text:0000000000003674                 mov     qword ptr [rbp-0E8h], 1
.text:000000000000367F                 mov     qword ptr [rbp-0E0h], 1
.text:000000000000368A                 lea     rax, [rbp-0D0h]
.text:0000000000003691                 sub     rsp, 8
.text:0000000000003695                 push    qword ptr [rbp-0E0h]
.text:000000000000369B                 push    qword ptr [rbp-0E8h]
.text:00000000000036A1                 push    qword ptr [rbp-0F0h]
.text:00000000000036A7                 mov     rdi, rax
.text:00000000000036AA                 call    _fmt_Println
.text:00000000000036AF                 add     rsp, 20h
.text:00000000000036B3                 mov     rax, [rbp-0D0h]
.text:00000000000036BA                 mov     rdx, [rbp-0C8h]
.text:00000000000036C1                 mov     [rbp-180h], rax
.text:00000000000036C8                 mov     [rbp-178h], rdx
.text:00000000000036CF                 mov     rax, [rbp-0C0h]
.text:00000000000036D6                 mov     [rbp-170h], rax
.text:00000000000036DD                 call    main_FuncConst
.text:00000000000036E2                 mov     rbx, rax
.text:00000000000036E5                 lea     r14, int__d
.text:00000000000036EC                 lea     rdi, int__d
.text:00000000000036F3                 call    _runtime_newobject
.text:00000000000036F8                 mov     [rbp-138h], rax
.text:00000000000036FF                 mov     rax, [rbp-138h]
.text:0000000000003706                 mov     [rax], rbx
.text:0000000000003709                 mov     rax, [rbp-138h]
.text:0000000000003710                 mov     r15, rax
.text:0000000000003713                 mov     [rbp-130h], r14
.text:000000000000371A                 mov     [rbp-128h], r15
.text:0000000000003721                 lea     rax, [rbp-130h]
.text:0000000000003728                 mov     [rbp-0B0h], rax
.text:000000000000372F                 mov     qword ptr [rbp-0A8h], 1
.text:000000000000373A                 mov     qword ptr [rbp-0A0h], 1
.text:0000000000003745                 lea     rax, [rbp-90h]
.text:000000000000374C                 sub     rsp, 8
.text:0000000000003750                 push    qword ptr [rbp-0A0h]
.text:0000000000003756                 push    qword ptr [rbp-0A8h]
.text:000000000000375C                 push    qword ptr [rbp-0B0h]
.text:0000000000003762                 mov     rdi, rax
.text:0000000000003765                 call    _fmt_Println
.text:000000000000376A                 add     rsp, 20h
.text:000000000000376E                 mov     rax, [rbp-90h]
.text:0000000000003775                 mov     rdx, [rbp-88h]
.text:000000000000377C                 mov     [rbp-150h], rax
.text:0000000000003783                 mov     [rbp-148h], rdx
.text:000000000000378A                 mov     rax, [rbp-80h]
.text:000000000000378E                 mov     [rbp-140h], rax
.text:0000000000003795                 mov     edx, 3
.text:000000000000379A                 mov     esi, 2
.text:000000000000379F                 mov     edi, 1
.text:00000000000037A4                 call    main_FuncAdd
.text:00000000000037A9                 mov     rbx, rax
.text:00000000000037AC                 lea     r12, int__d
.text:00000000000037B3                 lea     rdi, int__d
.text:00000000000037BA                 call    _runtime_newobject
.text:00000000000037BF                 mov     [rbp-108h], rax
.text:00000000000037C6                 mov     rax, [rbp-108h]
.text:00000000000037CD                 mov     [rax], rbx
.text:00000000000037D0                 mov     rax, [rbp-108h]
.text:00000000000037D7                 mov     r13, rax
.text:00000000000037DA                 mov     [rbp-100h], r12
.text:00000000000037E1                 mov     [rbp-0F8h], r13
.text:00000000000037E8                 lea     rax, [rbp-100h]
.text:00000000000037EF                 mov     [rbp-70h], rax
.text:00000000000037F3                 mov     qword ptr [rbp-68h], 1
.text:00000000000037FB                 mov     qword ptr [rbp-60h], 1
.text:0000000000003803                 lea     rax, [rbp-50h]
.text:0000000000003807                 sub     rsp, 8
.text:000000000000380B                 push    qword ptr [rbp-60h]
.text:000000000000380E                 push    qword ptr [rbp-68h]
.text:0000000000003811                 push    qword ptr [rbp-70h]
.text:0000000000003814                 mov     rdi, rax
.text:0000000000003817                 call    _fmt_Println
.text:000000000000381C                 add     rsp, 20h
.text:0000000000003820                 mov     rax, [rbp-50h]
.text:0000000000003824                 mov     rdx, [rbp-48h]
.text:0000000000003828                 mov     [rbp-120h], rax
.text:000000000000382F                 mov     [rbp-118h], rdx
.text:0000000000003836                 mov     rax, [rbp-40h]
.text:000000000000383A                 mov     [rbp-110h], rax
.text:0000000000003841                 lea     rsp, [rbp-28h]
.text:0000000000003845                 pop     rbx
.text:0000000000003846                 pop     r12
.text:0000000000003848                 pop     r13
.text:000000000000384A                 pop     r14
.text:000000000000384C                 pop     r15
.text:000000000000384E                 pop     rbp
.text:000000000000384F                 retn
.text:000000000000384F ; } // starts at 3611
.text:000000000000384F main_main       endp

值得注意的是

1
2
3
4
.text:0000000000003795                 mov     edx, 3
.text:000000000000379A                 mov     esi, 2
.text:000000000000379F                 mov     edi, 1
.text:00000000000037A4                 call    main_FuncAdd

原来Go语言中利用栈的临时变量传递方法会被优化成寄存器传递。

再开个O3试试。

1
gccgo -O3 1.go -o 1_o3_gcc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
.text:00000000000035D0 ; void __cdecl main_main()
.text:00000000000035D0                 public main_main
.text:00000000000035D0 main_main       proc near               ; DATA XREF: LOAD:0000000000000D08↑o
.text:00000000000035D0
.text:00000000000035D0 var_F8          = xmmword ptr -0F8h
.text:00000000000035D0 var_E8          = qword ptr -0E8h
.text:00000000000035D0 var_E0          = qword ptr -0E0h
.text:00000000000035D0 var_D8          = qword ptr -0D8h
.text:00000000000035D0 var_D0          = qword ptr -0D0h
.text:00000000000035D0 var_A8          = byte ptr -0A8h
.text:00000000000035D0 var_68          = byte ptr -68h
.text:00000000000035D0 var_28          = byte ptr -28h
.text:00000000000035D0
.text:00000000000035D0 ; __unwind {
.text:00000000000035D0                 cmp     rsp, fs:70h
.text:00000000000035D9                 jb      loc_36A1
.text:00000000000035DF
.text:00000000000035DF loc_35DF:                               ; CODE XREF: .text:00000000000036B0↓j
.text:00000000000035DF                 push    rbx
.text:00000000000035E0                 lea     rdx, string__d
.text:00000000000035E7                 lea     rax, go__C6
.text:00000000000035EE                 movq    xmm1, rax
.text:00000000000035F3                 movq    xmm0, rdx
.text:00000000000035F8                 lea     rbx, int__d
.text:00000000000035FF                 punpcklqdq xmm0, xmm1
.text:0000000000003603                 sub     rsp, 0F0h
.text:000000000000360A                 movaps  [rsp+0F8h+var_F8], xmm0
.text:000000000000360E                 mov     rax, rsp
.text:0000000000003611                 lea     rdi, [rsp+0F8h+var_A8]
.text:0000000000003616                 sub     rsp, 8
.text:000000000000361A                 push    1
.text:000000000000361C                 push    1
.text:000000000000361E                 push    rax
.text:000000000000361F                 call    _fmt_Println
.text:0000000000003624                 add     rsp, 20h
.text:0000000000003628                 lea     rdi, int__d
.text:000000000000362F                 call    _runtime_newobject
.text:0000000000003634                 lea     rdi, [rsp+0F8h+var_68]
.text:000000000000363C                 mov     qword ptr [rax], 7Bh ; '{'
.text:0000000000003643                 mov     [rsp+0F8h+var_E8], rbx
.text:0000000000003648                 mov     [rsp+0F8h+var_E0], rax
.text:000000000000364D                 lea     rax, [rsp+0F8h+var_E8]
.text:0000000000003652                 sub     rsp, 8
.text:0000000000003656                 push    1
.text:0000000000003658                 push    1
.text:000000000000365A                 push    rax
.text:000000000000365B                 call    _fmt_Println
.text:0000000000003660                 add     rsp, 20h
.text:0000000000003664                 mov     rdi, rbx
.text:0000000000003667                 call    _runtime_newobject
.text:000000000000366C                 lea     rdi, [rsp+0F8h+var_28]
.text:0000000000003674                 mov     qword ptr [rax], 0
.text:000000000000367B                 mov     [rsp+0F8h+var_D8], rbx
.text:0000000000003680                 mov     [rsp+0F8h+var_D0], rax
.text:0000000000003685                 lea     rax, [rsp+0F8h+var_D8]
.text:000000000000368A                 sub     rsp, 8
.text:000000000000368E                 push    1
.text:0000000000003690                 push    1
.text:0000000000003692                 push    rax
.text:0000000000003693                 call    _fmt_Println
.text:0000000000003698                 add     rsp, 110h
.text:000000000000369F                 pop     rbx
.text:00000000000036A0                 retn
.text:00000000000036A1 ; ---------------------------------------------------------------------------
.text:00000000000036A1
.text:00000000000036A1 loc_36A1:                               ; CODE XREF: main_main+9↑j
.text:00000000000036A1                 mov     r10d, 0F8h
.text:00000000000036A7                 xor     r11d, r11d
.text:00000000000036AA                 call    __morestack
.text:00000000000036AF                 retn
.text:00000000000036AF main_main       endp

压缩更厉害了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void __cdecl main_main()
{
  _QWORD *v0; // rax
  _QWORD *v1; // rax
  __m128i v2; // [rsp+0h] [rbp-F8h] BYREF
  __int64 v3[2]; // [rsp+10h] [rbp-E8h] BYREF
  __int64 v4[6]; // [rsp+20h] [rbp-D8h] BYREF
  void *retaddr; // [rsp+F8h] [rbp+0h] BYREF

  if ( (unsigned __int64)&retaddr < __readfsqword(0x70u) )
  {
    _morestack();
  }
  else
  {
    v2 = _mm_unpacklo_epi64((__m128i)(unsigned __int64)&string__d, (__m128i)(unsigned __int64)&go__C6);
    fmt_Println(&v2, 1LL, 1LL);
    v0 = (_QWORD *)runtime_newobject();
    *v0 = 123LL;
    v3[0] = (__int64)&int__d;
    v3[1] = (__int64)v0;
    fmt_Println(v3, 1LL, 1LL);
    v1 = (_QWORD *)runtime_newobject();
    *v1 = 0LL;
    v4[0] = (__int64)&int__d;
    v4[1] = (__int64)v1;
    fmt_Println(v4, 1LL, 1LL);
  }
}

反编译结果是这样的。大抵能知道调用了什么函数，但是具体传了什么参数还是得看汇编。

看第一个fmt.Println("AAA")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
.text:00000000000035DF                 push    rbx
.text:00000000000035E0                 lea     rdx, string__d
.text:00000000000035E7                 lea     rax, go__C6
.text:00000000000035EE                 movq    xmm1, rax
.text:00000000000035F3                 movq    xmm0, rdx
.text:00000000000035F8                 lea     rbx, int__d
.text:00000000000035FF                 punpcklqdq xmm0, xmm1
.text:0000000000003603                 sub     rsp, 0F0h
.text:000000000000360A                 movaps  [rsp+0F8h+var_F8], xmm0
.text:000000000000360E                 mov     rax, rsp
.text:0000000000003611                 lea     rdi, [rsp+0F8h+var_A8]
.text:0000000000003616                 sub     rsp, 8
.text:000000000000361A                 push    1
.text:000000000000361C                 push    1
.text:000000000000361E                 push    rax   ; v2
.text:000000000000361F                 call    _fmt_Println

反编译出来_fmt_Println(&v2, 1, 1)，第一个参数是一个string类结构体，上面能看到有个lea rax, go__C6

1
2
3
.data.rel.ro:00000000000078F0 go__C6          dq offset aAaa          ; DATA XREF: main_main+17↑o
.data.rel.ro:00000000000078F0                                         ; "AAA"
.data.rel.ro:00000000000078F8                 dq 3

这就是string类结构体。且字符串已经变成了C风格字符串，以\x00结尾的那种。

剩下的2个传入1的参数暂时不管，似乎是空接口的其他参数。

补充

关于Go接口

详解GO接口类型 - 知乎 (zhihu.com)

GO根据接口类型是否含有方法集将接口分为了两类：

  • iface非空接口，含有一组方法集
  • eface空接口，不含方法集

iface

1
2
3
4
type iface struct{
	tab *itab	// 指向一个内部表
	data unsafe.Pointer // 指向所持有的数据
}
  • itab指针指向一个itab结构体，该itab结构体记录了该接口值的一系列信息，包括接口静态类型信息，持有数据的动态类型信息，方法集等，用以进行 接口的类型转换，编译器类型检查，辅助反射等等；即：非空接口的itab既包含接口类型相关的信息，又包括所持数据的类型相关的信息
  • data是一个指向实际数据的指针

具体来看一下itab,这个结构体还是很重要的，是GO接口实现的基础。

1
2
3
4
5
6
7
type itab struct { // 32 bytes
    inter *interfacetype    // 类型的静态类型信息，比如io.Reader
    _type *_type            // 是一个结构体，记录所持有数据的类型相关的一系列信息
    hash  uint32            // 
    _     [4]byte
    fun   [1]uintptr        // 存储接口的方法集
}

从iface或itab都可以看出，接口interface包含有两种类型：

  • 一种是接口自身的类型，称为接口的静态类型，比如io.Reader等，用于确定接口类型，直接存储在itab结构体中
  • 一种是接口所持有数据的类型，称为接口的动态类型，用于在反射或者接口转换时确认所持有数据的实际类型，存储在运行时runtime/_type结构体中。

hash是一个uint32类型的值，实际上可以看作是类型的校验码，当将接口转换成具体的类型的时候，会通过比较二者的hash值确定是否相等，只有hash相等 才能进行转换。

fun最终指向的是接口的方法集，即存储了接口所有方法的函数的指针。通过比较接口的方法集和类型的方法集，可以用来判断该类型是否实现了该接口。 把fun指向的方法集看作是一个虚函数表，也是很贴切的。

最后再简单看一下运行时runtime/_type结构体。该结构体包含了GO类型的所有类型信息，如类型大小/类别/哈希等等。 只需要有这个概念就好。

1
2
3
4
5
6
7
8
9
10
11
12
13
type _type struct {
    size       uintptr  // 类型大小
    ptrdata    uintptr
    hash       uint32   // 前面阐述过，相当于类型的校验码
    tflag      tflag
    align      uint8    // 对齐方式
    fieldAlign uint8
    kind       uint8    // 类别
    equal      func(unsafe.Pointer, unsafe.Pointer) bool
    gcdata     *byte
    str        nameOff
    ptrToThis  typeOff
}

eface

空接口类型也是接口类型的一种，只不过它没有方法集，同时空接口也是GO实现多态的基础，因此将空接口进行单独定义，一来简化底层数据结构，二来更好的支持GO的运行时多态。

1
2
3
4
type eface struct{ // 两个指针，16byte
    _type *_type          // 指向一个内部表
    data unsafe.Pointer   // 指向所持有的数据
}

第一个参数直接就是_type结构体指针了，而不是拥有更多具体描述的itab。

接口的nil和non-nil

从上面接口的底层数据结构可以看出，接口总是存在两个指针类型的字段。因此，当且仅当该接口值的两个字段都是nil的时候，该接口==nil才成立。

更不能想当然的认为空接口==nil，因为判断接口是否等于nil只有一种条件，即其两个字段都是nil。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
    var a interface{}  // 申明一个空接口，此时a的类型字段和数据字段都是nil

    var x *int             // x==nil,但x仍然有类型(*int)
    var b interface{} = x  // 将x赋给一个空接口，则该空接口保存了x的类型信息(*int)和x的值(nil)

    var y int = 5                          // y!=nil,y有值(5),有类型(int)
    var c interface{} = (int)(y)         // 将y赋给一个空接口，该空接口保存了y的类型信息(*int)和y的值(y的内存地址)

    // %T会输出接口所持有数据的类型，实际上底层会调用reflect.TypeOf(i)
    fmt.Printf("a type: %T, value: %v, a==nil? %v\n", a, a, a==nil)  // 输出：a type: <nil>, value: <nil>, a==nil? true
    fmt.Printf("b type: %T, value: %v, b==nil? %v\n", b, b, b==nil)  // 输出：b type: *int,  value: <nil>, b==nil? false
    fmt.Printf("c type: %T, value: %v, c==nil? %v\n", c, c, c==nil)  // 输出：c type: int,   value: 5,     c==nil? false
}

简单点的意思就是类型和值都得是nil才行。

参考

The Go low-level calling convention on x86-64 · dr knz @ work (dr-knz.net)

18年很详细的举例说明文章。

1.4 Plan 9 汇编语言 | Go 语言原本 (golang.design)

https://quasilyte.dev/blog/post/go-asm-complementary-reference/#register-names

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

A junior undergraduate
studying in the college of cyber science and engineering
in Sichuan University
in Sichuan , China.
Pronouns:He/him.
A core member of 0x401 CTF team
majorly focus on Reverse Engineering chanllenges.